diff --git a/clang-tools-extra/clang-tidy/readability/QualifiedAutoCheck.cpp b/clang-tools-extra/clang-tidy/readability/QualifiedAutoCheck.cpp
--- a/clang-tools-extra/clang-tidy/readability/QualifiedAutoCheck.cpp
+++ b/clang-tools-extra/clang-tidy/readability/QualifiedAutoCheck.cpp
@@ -128,7 +128,7 @@
   auto UnlessFunctionType = unless(hasUnqualifiedDesugaredType(functionType()));
   auto IsAutoDeducedToPointer = [](const auto &...InnerMatchers) {
     return autoType(hasDeducedType(
-        hasUnqualifiedDesugaredType(pointerType(pointee(InnerMatchers...)))));
+        hasCanonicalType(pointerType(pointee(InnerMatchers...)))));
   };
 
   Finder->addMatcher(
diff --git a/clang-tools-extra/clangd/unittests/HoverTests.cpp b/clang-tools-extra/clangd/unittests/HoverTests.cpp
--- a/clang-tools-extra/clangd/unittests/HoverTests.cpp
+++ b/clang-tools-extra/clangd/unittests/HoverTests.cpp
@@ -1067,7 +1067,7 @@
          HI.LocalScope = "";
          HI.Kind = index::SymbolKind::TypeAlias;
          HI.Definition = "template <typename T> using AA = A<T>";
-         HI.Type = {"A<T>", "type-parameter-0-0"}; // FIXME: should be 'T'
+         HI.Type = {"A<T>", "T"};
          HI.TemplateParameters = {{{"typename"}, std::string("T"), llvm::None}};
        }},
       {// Constant array
diff --git a/clang/include/clang/AST/ASTImporter.h b/clang/include/clang/AST/ASTImporter.h
--- a/clang/include/clang/AST/ASTImporter.h
+++ b/clang/include/clang/AST/ASTImporter.h
@@ -480,6 +480,13 @@
     /// error.
     llvm::Expected<APValue> Import(const APValue &FromValue);
 
+    /// Import the given C++ TemplateArgumentList from the "from"
+    /// context into the "to" context.
+    ///
+    /// \returns The equivalent initializer in the "to" context, or the import
+    /// error.
+    llvm::Expected<TemplateArgumentList *> Import(const TemplateArgumentList *);
+
     /// Import the definition of the given declaration, including all of
     /// the declarations it contains.
     [[nodiscard]] llvm::Error ImportDefinition(Decl *From);
diff --git a/clang/include/clang/AST/DeclTemplate.h b/clang/include/clang/AST/DeclTemplate.h
--- a/clang/include/clang/AST/DeclTemplate.h
+++ b/clang/include/clang/AST/DeclTemplate.h
@@ -2141,11 +2141,9 @@
   static ClassTemplatePartialSpecializationDecl *
   Create(ASTContext &Context, TagKind TK, DeclContext *DC,
          SourceLocation StartLoc, SourceLocation IdLoc,
-         TemplateParameterList *Params,
-         ClassTemplateDecl *SpecializedTemplate,
+         TemplateParameterList *Params, ClassTemplateDecl *SpecializedTemplate,
          ArrayRef<TemplateArgument> Args,
-         const TemplateArgumentListInfo &ArgInfos,
-         QualType CanonInjectedType,
+         const TemplateArgumentListInfo &ArgInfos, QualType InjectedType,
          ClassTemplatePartialSpecializationDecl *PrevDecl);
 
   static ClassTemplatePartialSpecializationDecl *
diff --git a/clang/include/clang/AST/Expr.h b/clang/include/clang/AST/Expr.h
--- a/clang/include/clang/AST/Expr.h
+++ b/clang/include/clang/AST/Expr.h
@@ -3175,6 +3175,8 @@
   /// In X.F, this is the decl referenced by F.
   ValueDecl *MemberDecl;
 
+  const TemplateArgumentList *Deduced;
+
   /// MemberDNLoc - Provides source/type location info for the
   /// declaration name embedded in MemberDecl.
   DeclarationNameLoc MemberDNLoc;
@@ -3200,21 +3202,20 @@
 
   MemberExpr(Expr *Base, bool IsArrow, SourceLocation OperatorLoc,
              ValueDecl *MemberDecl, const DeclarationNameInfo &NameInfo,
-             QualType T, ExprValueKind VK, ExprObjectKind OK,
-             NonOdrUseReason NOUR);
+             const TemplateArgumentList *Deduced, QualType T, ExprValueKind VK,
+             ExprObjectKind OK, NonOdrUseReason NOUR);
   MemberExpr(EmptyShell Empty)
       : Expr(MemberExprClass, Empty), Base(), MemberDecl() {}
 
 public:
-  static MemberExpr *Create(const ASTContext &C, Expr *Base, bool IsArrow,
-                            SourceLocation OperatorLoc,
-                            NestedNameSpecifierLoc QualifierLoc,
-                            SourceLocation TemplateKWLoc, ValueDecl *MemberDecl,
-                            DeclAccessPair FoundDecl,
-                            DeclarationNameInfo MemberNameInfo,
-                            const TemplateArgumentListInfo *TemplateArgs,
-                            QualType T, ExprValueKind VK, ExprObjectKind OK,
-                            NonOdrUseReason NOUR);
+  static MemberExpr *
+  Create(const ASTContext &C, Expr *Base, bool IsArrow,
+         SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc,
+         SourceLocation TemplateKWLoc, ValueDecl *MemberDecl,
+         DeclAccessPair FoundDecl, DeclarationNameInfo MemberNameInfo,
+         const TemplateArgumentListInfo *TemplateArgs,
+         const TemplateArgumentList *Deduced, QualType T, ExprValueKind VK,
+         ExprObjectKind OK, NonOdrUseReason NOUR);
 
   /// Create an implicit MemberExpr, with no location, qualifier, template
   /// arguments, and so on. Suitable only for non-static member access.
@@ -3225,7 +3226,8 @@
     return Create(C, Base, IsArrow, SourceLocation(), NestedNameSpecifierLoc(),
                   SourceLocation(), MemberDecl,
                   DeclAccessPair::make(MemberDecl, MemberDecl->getAccess()),
-                  DeclarationNameInfo(), nullptr, T, VK, OK, NOUR_None);
+                  DeclarationNameInfo(), nullptr, nullptr, T, VK, OK,
+                  NOUR_None);
   }
 
   static MemberExpr *CreateEmpty(const ASTContext &Context, bool HasQualifier,
@@ -3251,6 +3253,8 @@
     return getTrailingObjects<MemberExprNameQualifier>()->FoundDecl;
   }
 
+  const TemplateArgumentList *getDeduced() const { return Deduced; }
+
   /// Determines whether this member expression actually had
   /// a C++ nested-name-specifier prior to the name of the member, e.g.,
   /// x->Base::foo.
diff --git a/clang/include/clang/AST/TypeLoc.h b/clang/include/clang/AST/TypeLoc.h
--- a/clang/include/clang/AST/TypeLoc.h
+++ b/clang/include/clang/AST/TypeLoc.h
@@ -901,7 +901,7 @@
   }
 };
 
-struct BTFTagAttributedLocInfo {}; // Nothing.
+struct alignas(4) BTFTagAttributedLocInfo {}; // Nothing.
 
 /// Type source information for an btf_tag attributed type.
 class BTFTagAttributedTypeLoc
diff --git a/clang/include/clang/Basic/LangOptions.h b/clang/include/clang/Basic/LangOptions.h
--- a/clang/include/clang/Basic/LangOptions.h
+++ b/clang/include/clang/Basic/LangOptions.h
@@ -472,6 +472,9 @@
   /// forward slash (/) elsewhere.
   bool UseTargetPathSeparator = false;
 
+  /// Resugar template specializations.
+  bool Resugar = true;
+
   LangOptions();
 
   /// Set language defaults for the given input language and
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
--- a/clang/include/clang/Driver/Options.td
+++ b/clang/include/clang/Driver/Options.td
@@ -5831,6 +5831,9 @@
   LangOpts<"RecoveryASTType">, DefaultTrue,
   NegFlag<SetFalse>, PosFlag<SetTrue, [], "Preserve the type for recovery "
                               "expressions when possible">>;
+def fno_resugar : Flag<["-"], "fno-resugar">,
+  HelpText<"Do not resugar template specializations">,
+  MarshallingInfoNegativeFlag<LangOpts<"Resugar">>;
 
 let Group = Action_Group in {
 
diff --git a/clang/include/clang/Sema/Overload.h b/clang/include/clang/Sema/Overload.h
--- a/clang/include/clang/Sema/Overload.h
+++ b/clang/include/clang/Sema/Overload.h
@@ -885,6 +885,9 @@
       StandardConversionSequence FinalConversion;
     };
 
+    /// Deduced Arguments for Function Templates.
+    const TemplateArgumentList *Deduced;
+
     /// Get RewriteKind value in OverloadCandidateRewriteKind type (This
     /// function is to workaround the spurious GCC bitfield enum warning)
     OverloadCandidateRewriteKind getRewriteKind() const {
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -3882,7 +3882,8 @@
                             bool AllowExplicitConversion = false,
                             ADLCallKind IsADLCandidate = ADLCallKind::NotADL,
                             ConversionSequenceList EarlyConversions = None,
-                            OverloadCandidateParamOrder PO = {});
+                            OverloadCandidateParamOrder PO = {},
+                            const TemplateArgumentList *Deduced = nullptr);
   void AddFunctionCandidates(const UnresolvedSetImpl &Functions,
                       ArrayRef<Expr *> Args,
                       OverloadCandidateSet &CandidateSet,
@@ -3897,16 +3898,16 @@
                           OverloadCandidateSet& CandidateSet,
                           bool SuppressUserConversion = false,
                           OverloadCandidateParamOrder PO = {});
-  void AddMethodCandidate(CXXMethodDecl *Method,
-                          DeclAccessPair FoundDecl,
+  void AddMethodCandidate(CXXMethodDecl *Method, DeclAccessPair FoundDecl,
                           CXXRecordDecl *ActingContext, QualType ObjectType,
                           Expr::Classification ObjectClassification,
                           ArrayRef<Expr *> Args,
-                          OverloadCandidateSet& CandidateSet,
+                          OverloadCandidateSet &CandidateSet,
                           bool SuppressUserConversions = false,
                           bool PartialOverloading = false,
                           ConversionSequenceList EarlyConversions = None,
-                          OverloadCandidateParamOrder PO = {});
+                          OverloadCandidateParamOrder PO = {},
+                          const TemplateArgumentList *Deduced = nullptr);
   void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl,
                                   DeclAccessPair FoundDecl,
                                   CXXRecordDecl *ActingContext,
@@ -4042,10 +4043,9 @@
   bool resolveAndFixAddressOfSingleOverloadCandidate(
       ExprResult &SrcExpr, bool DoFunctionPointerConversion = false);
 
-  FunctionDecl *
-  ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl,
-                                              bool Complain = false,
-                                              DeclAccessPair *Found = nullptr);
+  FunctionDecl *ResolveSingleFunctionTemplateSpecialization(
+      OverloadExpr *ovl, TemplateArgumentListInfo &ExplicitTemplateArgs,
+      bool Complain = false, DeclAccessPair *Found = nullptr);
 
   bool ResolveAndFixSingleFunctionTemplateSpecialization(
       ExprResult &SrcExpr, bool DoFunctionPointerConversion = false,
@@ -4053,12 +4053,13 @@
       QualType DestTypeForComplaining = QualType(),
       unsigned DiagIDForComplaining = 0);
 
-  Expr *FixOverloadedFunctionReference(Expr *E,
-                                       DeclAccessPair FoundDecl,
-                                       FunctionDecl *Fn);
-  ExprResult FixOverloadedFunctionReference(ExprResult,
-                                            DeclAccessPair FoundDecl,
-                                            FunctionDecl *Fn);
+  Expr *FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl,
+                                       FunctionDecl *Fn,
+                                       const TemplateArgumentList *Deduced);
+  ExprResult
+  FixOverloadedFunctionReference(ExprResult, DeclAccessPair FoundDecl,
+                                 FunctionDecl *Fn,
+                                 const TemplateArgumentList *Deduced);
 
   void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE,
                                    ArrayRef<Expr *> Args,
@@ -5478,13 +5479,11 @@
                    SourceLocation TemplateKWLoc = SourceLocation(),
                    const TemplateArgumentListInfo *TemplateArgs = nullptr);
 
-  ExprResult
-  BuildAnonymousStructUnionMemberReference(
-      const CXXScopeSpec &SS,
-      SourceLocation nameLoc,
+  ExprResult BuildAnonymousStructUnionMemberReference(
+      const CXXScopeSpec &SS, SourceLocation nameLoc,
       IndirectFieldDecl *indirectField,
       DeclAccessPair FoundDecl = DeclAccessPair::make(nullptr, AS_none),
-      Expr *baseObjectExpr = nullptr,
+      Expr *baseObjectExpr = nullptr, const Type *BaseType = nullptr,
       SourceLocation opLoc = SourceLocation());
 
   ExprResult BuildPossibleImplicitMemberExpr(
@@ -5677,7 +5676,8 @@
 
   ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow,
                                      SourceLocation OpLoc,
-                                     const CXXScopeSpec &SS, FieldDecl *Field,
+                                     const NestedNameSpecifierLoc &NNS,
+                                     FieldDecl *Field, QualType FieldType,
                                      DeclAccessPair FoundDecl,
                                      const DeclarationNameInfo &MemberNameInfo);
 
@@ -5703,22 +5703,20 @@
                                    UnqualifiedId &Member,
                                    Decl *ObjCImpDecl);
 
-  MemberExpr *
-  BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc,
-                  const CXXScopeSpec *SS, SourceLocation TemplateKWLoc,
-                  ValueDecl *Member, DeclAccessPair FoundDecl,
-                  bool HadMultipleCandidates,
-                  const DeclarationNameInfo &MemberNameInfo, QualType Ty,
-                  ExprValueKind VK, ExprObjectKind OK,
-                  const TemplateArgumentListInfo *TemplateArgs = nullptr);
-  MemberExpr *
-  BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc,
-                  NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc,
-                  ValueDecl *Member, DeclAccessPair FoundDecl,
-                  bool HadMultipleCandidates,
-                  const DeclarationNameInfo &MemberNameInfo, QualType Ty,
-                  ExprValueKind VK, ExprObjectKind OK,
-                  const TemplateArgumentListInfo *TemplateArgs = nullptr);
+  MemberExpr *BuildMemberExpr(
+      Expr *Base, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec *SS,
+      SourceLocation TemplateKWLoc, ValueDecl *Member, DeclAccessPair FoundDecl,
+      bool HadMultipleCandidates, const DeclarationNameInfo &MemberNameInfo,
+      QualType Ty, ExprValueKind VK, ExprObjectKind OK,
+      const TemplateArgumentListInfo *TemplateArgs = nullptr,
+      const TemplateArgumentList *Deduced = nullptr);
+  MemberExpr *BuildMemberExpr(
+      Expr *Base, bool IsArrow, SourceLocation OpLoc,
+      NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc,
+      ValueDecl *Member, DeclAccessPair FoundDecl, bool HadMultipleCandidates,
+      const DeclarationNameInfo &MemberNameInfo, QualType Ty, ExprValueKind VK,
+      ExprObjectKind OK, const TemplateArgumentListInfo *TemplateArgs = nullptr,
+      const TemplateArgumentList *Deduced = nullptr);
 
   void ActOnDefaultCtorInitializers(Decl *CDtorDecl);
   bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
@@ -7954,9 +7952,9 @@
 
   void NoteAllFoundTemplates(TemplateName Name);
 
-  QualType CheckTemplateIdType(TemplateName Template,
+  QualType CheckTemplateIdType(const CXXScopeSpec &SS, TemplateName Template,
                                SourceLocation TemplateLoc,
-                              TemplateArgumentListInfo &TemplateArgs);
+                               TemplateArgumentListInfo &TemplateArgs);
 
   TypeResult
   ActOnTemplateIdType(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
@@ -9642,6 +9640,29 @@
     }
   };
 
+  QualType resugar(const CXXScopeSpec &SS, QualType T);
+
+  QualType resugar(const CXXScopeSpec &SS, NamedDecl *ND,
+                   ArrayRef<TemplateArgumentLoc> Args, QualType T);
+  QualType resugar(const CXXScopeSpec &SS, NamedDecl *ND,
+                   ArrayRef<TemplateArgument> Args, QualType T);
+
+  QualType resugar(const Type *Base, NestedNameSpecifierLoc &FieldNNS,
+                   QualType T);
+
+  QualType resugar(const Type *Base, NestedNameSpecifierLoc &FieldNNS,
+                   NamedDecl *ND, ArrayRef<TemplateArgumentLoc> Args,
+                   QualType T);
+  QualType resugar(const Type *Base, NestedNameSpecifierLoc &FieldNNS,
+                   NamedDecl *ND, ArrayRef<TemplateArgument> Args, QualType T);
+
+  QualType resugar(const Type *Base, QualType T);
+
+  QualType resugar(const Type *Base, NamedDecl *ND,
+                   ArrayRef<TemplateArgumentLoc> Args, QualType T);
+  QualType resugar(const Type *Base, NamedDecl *ND,
+                   ArrayRef<TemplateArgument> Args, QualType T);
+
   void PerformPendingInstantiations(bool LocalOnly = false);
 
   TypeSourceInfo *SubstType(TypeSourceInfo *T,
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -4806,6 +4806,7 @@
 QualType
 ASTContext::getSubstTemplateTypeParmPackType(Decl *ReplacedDecl, unsigned Index,
                                              const TemplateArgument &ArgPack) {
+  // FIXME: Allow non-canonical argument pack.
 #ifndef NDEBUG
   for (const auto &P : ArgPack.pack_elements()) {
     assert(P.getKind() == TemplateArgument::Type && "Pack contains a non-type");
diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp
--- a/clang/lib/AST/ASTImporter.cpp
+++ b/clang/lib/AST/ASTImporter.cpp
@@ -7951,6 +7951,7 @@
   auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
   auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
   auto ToMemberDecl = importChecked(Err, E->getMemberDecl());
+  auto ToDeduced = importChecked(Err, E->getDeduced());
   auto ToType = importChecked(Err, E->getType());
   auto ToDecl = importChecked(Err, E->getFoundDecl().getDecl());
   auto ToName = importChecked(Err, E->getMemberNameInfo().getName());
@@ -7975,7 +7976,7 @@
   return MemberExpr::Create(Importer.getToContext(), ToBase, E->isArrow(),
                             ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc,
                             ToMemberDecl, ToFoundDecl, ToMemberNameInfo,
-                            ResInfo, ToType, E->getValueKind(),
+                            ResInfo, ToDeduced, ToType, E->getValueKind(),
                             E->getObjectKind(), E->isNonOdrUse());
 }
 
@@ -9655,6 +9656,17 @@
   return Importer.ImportAPValue(FromValue);
 }
 
+llvm::Expected<TemplateArgumentList *>
+ASTImporter::Import(const TemplateArgumentList *ArgList) {
+  ASTNodeImporter Importer(*this);
+  if (!ArgList)
+    return nullptr;
+  SmallVector<TemplateArgument, 4> ToArgs(ArgList->size());
+  if (auto Res = Importer.ImportTemplateArguments(ArgList->asArray(), ToArgs))
+    return std::move(Res);
+  return TemplateArgumentList::CreateCopy(ToContext, ToArgs);
+}
+
 Error ASTImporter::ImportDefinition(Decl *From) {
   ExpectedDecl ToOrErr = Import(From);
   if (!ToOrErr)
diff --git a/clang/lib/AST/DeclTemplate.cpp b/clang/lib/AST/DeclTemplate.cpp
--- a/clang/lib/AST/DeclTemplate.cpp
+++ b/clang/lib/AST/DeclTemplate.cpp
@@ -1076,15 +1076,12 @@
 }
 
 ClassTemplatePartialSpecializationDecl *
-ClassTemplatePartialSpecializationDecl::
-Create(ASTContext &Context, TagKind TK,DeclContext *DC,
-       SourceLocation StartLoc, SourceLocation IdLoc,
-       TemplateParameterList *Params,
-       ClassTemplateDecl *SpecializedTemplate,
-       ArrayRef<TemplateArgument> Args,
-       const TemplateArgumentListInfo &ArgInfos,
-       QualType CanonInjectedType,
-       ClassTemplatePartialSpecializationDecl *PrevDecl) {
+ClassTemplatePartialSpecializationDecl::Create(
+    ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc,
+    SourceLocation IdLoc, TemplateParameterList *Params,
+    ClassTemplateDecl *SpecializedTemplate, ArrayRef<TemplateArgument> Args,
+    const TemplateArgumentListInfo &ArgInfos, QualType InjectedType,
+    ClassTemplatePartialSpecializationDecl *PrevDecl) {
   const ASTTemplateArgumentListInfo *ASTArgInfos =
     ASTTemplateArgumentListInfo::Create(Context, ArgInfos);
 
@@ -1095,7 +1092,7 @@
   Result->setSpecializationKind(TSK_ExplicitSpecialization);
   Result->setMayHaveOutOfDateDef(false);
 
-  Context.getInjectedClassNameType(Result, CanonInjectedType);
+  Context.getInjectedClassNameType(Result, InjectedType);
   return Result;
 }
 
diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp
--- a/clang/lib/AST/Expr.cpp
+++ b/clang/lib/AST/Expr.cpp
@@ -1612,11 +1612,13 @@
 
 MemberExpr::MemberExpr(Expr *Base, bool IsArrow, SourceLocation OperatorLoc,
                        ValueDecl *MemberDecl,
-                       const DeclarationNameInfo &NameInfo, QualType T,
+                       const DeclarationNameInfo &NameInfo,
+                       const TemplateArgumentList *Deduced, QualType T,
                        ExprValueKind VK, ExprObjectKind OK,
                        NonOdrUseReason NOUR)
     : Expr(MemberExprClass, T, VK, OK), Base(Base), MemberDecl(MemberDecl),
-      MemberDNLoc(NameInfo.getInfo()), MemberLoc(NameInfo.getLoc()) {
+      Deduced(Deduced), MemberDNLoc(NameInfo.getInfo()),
+      MemberLoc(NameInfo.getLoc()) {
   assert(!NameInfo.getName() ||
          MemberDecl->getDeclName() == NameInfo.getName());
   MemberExprBits.IsArrow = IsArrow;
@@ -1633,7 +1635,8 @@
     NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
     ValueDecl *MemberDecl, DeclAccessPair FoundDecl,
     DeclarationNameInfo NameInfo, const TemplateArgumentListInfo *TemplateArgs,
-    QualType T, ExprValueKind VK, ExprObjectKind OK, NonOdrUseReason NOUR) {
+    const TemplateArgumentList *Deduced, QualType T, ExprValueKind VK,
+    ExprObjectKind OK, NonOdrUseReason NOUR) {
   bool HasQualOrFound = QualifierLoc || FoundDecl.getDecl() != MemberDecl ||
                         FoundDecl.getAccess() != MemberDecl->getAccess();
   bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.isValid();
@@ -1645,7 +1648,7 @@
 
   void *Mem = C.Allocate(Size, alignof(MemberExpr));
   MemberExpr *E = new (Mem) MemberExpr(Base, IsArrow, OperatorLoc, MemberDecl,
-                                       NameInfo, T, VK, OK, NOUR);
+                                       NameInfo, Deduced, T, VK, OK, NOUR);
 
   // FIXME: remove remaining dependence computation to computeDependence().
   auto Deps = E->getDependence();
diff --git a/clang/lib/Analysis/BodyFarm.cpp b/clang/lib/Analysis/BodyFarm.cpp
--- a/clang/lib/Analysis/BodyFarm.cpp
+++ b/clang/lib/Analysis/BodyFarm.cpp
@@ -230,8 +230,8 @@
       C, base, IsArrow, SourceLocation(), NestedNameSpecifierLoc(),
       SourceLocation(), MemberDecl, FoundDecl,
       DeclarationNameInfo(MemberDecl->getDeclName(), SourceLocation()),
-      /* TemplateArgumentListInfo=*/ nullptr, MemberDecl->getType(), ValueKind,
-      OK_Ordinary, NOUR_None);
+      /* TemplateArgumentListInfo=*/nullptr, /*Deduced=*/nullptr,
+      MemberDecl->getType(), ValueKind, OK_Ordinary, NOUR_None);
 }
 
 ValueDecl *ASTMaker::findMemberField(const RecordDecl *RD, StringRef Name) {
diff --git a/clang/lib/Sema/SemaCXXScopeSpec.cpp b/clang/lib/Sema/SemaCXXScopeSpec.cpp
--- a/clang/lib/Sema/SemaCXXScopeSpec.cpp
+++ b/clang/lib/Sema/SemaCXXScopeSpec.cpp
@@ -99,8 +99,7 @@
         if (ClassTemplateDecl *ClassTemplate
               = dyn_cast_or_null<ClassTemplateDecl>(
                             SpecType->getTemplateName().getAsTemplateDecl())) {
-          QualType ContextType
-            = Context.getCanonicalType(QualType(SpecType, 0));
+          auto ContextType = QualType(SpecType, 0);
 
           // If the type of the nested name specifier is the same as the
           // injected class name of the named class template, we're entering
@@ -734,8 +733,8 @@
       return false;
     }
 
-    QualType T =
-        Context.getTypeDeclType(cast<TypeDecl>(SD->getUnderlyingDecl()));
+    QualType T = resugar(
+        SS, Context.getTypeDeclType(cast<TypeDecl>(SD->getUnderlyingDecl())));
 
     if (T->isEnumeralType())
       Diag(IdInfo.IdentifierLoc, diag::warn_cxx98_compat_enum_nested_name_spec);
@@ -875,17 +874,19 @@
   QualType T = BuildDecltypeType(DS.getRepAsExpr());
   if (T.isNull())
     return true;
+  T = resugar(SS, T);
+
+  TypeLocBuilder TLB;
+  DecltypeTypeLoc DecltypeTL = TLB.push<DecltypeTypeLoc>(T);
+  DecltypeTL.setDecltypeLoc(DS.getTypeSpecTypeLoc());
+  DecltypeTL.setRParenLoc(DS.getTypeofParensRange().getEnd());
 
   if (!T->isDependentType() && !T->getAs<TagType>()) {
     Diag(DS.getTypeSpecTypeLoc(), diag::err_expected_class_or_namespace)
-      << T << getLangOpts().CPlusPlus;
+        << T << getLangOpts().CPlusPlus;
     return true;
   }
 
-  TypeLocBuilder TLB;
-  DecltypeTypeLoc DecltypeTL = TLB.push<DecltypeTypeLoc>(T);
-  DecltypeTL.setDecltypeLoc(DS.getTypeSpecTypeLoc());
-  DecltypeTL.setRParenLoc(DS.getTypeofParensRange().getEnd());
   SS.Extend(Context, SourceLocation(), TLB.getTypeLocInContext(Context, T),
             ColonColonLoc);
   return false;
@@ -974,18 +975,10 @@
 
   // We were able to resolve the template name to an actual template.
   // Build an appropriate nested-name-specifier.
-  QualType T = CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);
+  QualType T = CheckTemplateIdType(SS, Template, TemplateNameLoc, TemplateArgs);
   if (T.isNull())
     return true;
 
-  // Alias template specializations can produce types which are not valid
-  // nested name specifiers.
-  if (!T->isDependentType() && !T->getAs<TagType>()) {
-    Diag(TemplateNameLoc, diag::err_nested_name_spec_non_tag) << T;
-    NoteAllFoundTemplates(Template);
-    return true;
-  }
-
   // Provide source-location information for the template specialization type.
   TypeLocBuilder Builder;
   TemplateSpecializationTypeLoc SpecTL
@@ -997,6 +990,13 @@
   for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
     SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
 
+  // Alias template specializations can produce types which are not valid
+  // nested name specifiers.
+  if (!T->isDependentType() && !T->getAs<TagType>()) {
+    Diag(TemplateNameLoc, diag::err_nested_name_spec_non_tag) << T;
+    NoteAllFoundTemplates(Template);
+    return true;
+  }
 
   SS.Extend(Context, TemplateKWLoc, Builder.getTypeLocInContext(Context, T),
             CCLoc);
diff --git a/clang/lib/Sema/SemaCast.cpp b/clang/lib/Sema/SemaCast.cpp
--- a/clang/lib/Sema/SemaCast.cpp
+++ b/clang/lib/Sema/SemaCast.cpp
@@ -1808,7 +1808,9 @@
       return TC_Failed;
     }
 
-    SrcExpr = Self.FixOverloadedFunctionReference(SrcExpr, FoundOverload, Fn);
+    // FIXME: resugar
+    SrcExpr = Self.FixOverloadedFunctionReference(SrcExpr, FoundOverload, Fn,
+                                                  nullptr);
     if (!SrcExpr.isUsable()) {
       msg = 0;
       return TC_Failed;
@@ -2885,7 +2887,9 @@
     DeclAccessPair DAP;
     if (FunctionDecl *FD = Self.ResolveAddressOfOverloadedFunction(
             SrcExpr.get(), DestType, /*Complain=*/true, DAP))
-      SrcExpr = Self.FixOverloadedFunctionReference(SrcExpr.get(), DAP, FD);
+      // FIXME: resugar
+      SrcExpr =
+          Self.FixOverloadedFunctionReference(SrcExpr.get(), DAP, FD, nullptr);
     else
       return;
     assert(SrcExpr.isUsable());
diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -587,9 +587,11 @@
       if (!FD || FD->isUnnamedBitfield() || FD->isAnonymousStructOrUnion())
         continue;
 
+      QualType FieldType = FD->getType();
+
       llvm::SmallString<20> Format = llvm::StringRef("%s%s %s ");
       llvm::SmallVector<Expr *, 5> Args = {FieldIndentArg,
-                                           getTypeString(FD->getType()),
+                                           getTypeString(FieldType),
                                            getStringLiteral(FD->getName())};
 
       if (FD->isBitField()) {
@@ -605,15 +607,16 @@
       ExprResult Field =
           IFD ? S.BuildAnonymousStructUnionMemberReference(
                     CXXScopeSpec(), Loc, IFD,
-                    DeclAccessPair::make(IFD, AS_public), RecordArg, Loc)
+                    DeclAccessPair::make(IFD, AS_public), RecordArg, nullptr,
+                    Loc)
               : S.BuildFieldReferenceExpr(
-                    RecordArg, RecordArgIsPtr, Loc, CXXScopeSpec(), FD,
-                    DeclAccessPair::make(FD, AS_public),
+                    RecordArg, RecordArgIsPtr, Loc, NestedNameSpecifierLoc(),
+                    FD, FieldType, DeclAccessPair::make(FD, AS_public),
                     DeclarationNameInfo(FD->getDeclName(), Loc));
       if (Field.isInvalid())
         return true;
 
-      auto *InnerRD = FD->getType()->getAsRecordDecl();
+      auto *InnerRD = FieldType->getAsRecordDecl();
       auto *InnerCXXRD = dyn_cast_or_null<CXXRecordDecl>(InnerRD);
       if (InnerRD && (!InnerCXXRD || InnerCXXRD->isAggregate())) {
         // Recursively print the values of members of aggregate record type.
@@ -622,7 +625,7 @@
           return true;
       } else {
         Format += " ";
-        if (appendFormatSpecifier(FD->getType(), Format)) {
+        if (appendFormatSpecifier(FieldType, Format)) {
           // We know how to print this field.
           Args.push_back(Field.get());
         } else {
diff --git a/clang/lib/Sema/SemaCoroutine.cpp b/clang/lib/Sema/SemaCoroutine.cpp
--- a/clang/lib/Sema/SemaCoroutine.cpp
+++ b/clang/lib/Sema/SemaCoroutine.cpp
@@ -91,8 +91,8 @@
     AddArg(T);
 
   // Build the template-id.
-  QualType CoroTrait =
-      S.CheckTemplateIdType(TemplateName(CoroTraits), KwLoc, Args);
+  QualType CoroTrait = S.CheckTemplateIdType(
+      CXXScopeSpec(), TemplateName(CoroTraits), KwLoc, Args);
   if (CoroTrait.isNull())
     return QualType();
   if (S.RequireCompleteType(KwLoc, CoroTrait,
@@ -169,8 +169,8 @@
       S.Context.getTrivialTypeSourceInfo(PromiseType, Loc)));
 
   // Build the template-id.
-  QualType CoroHandleType =
-      S.CheckTemplateIdType(TemplateName(CoroHandle), Loc, Args);
+  QualType CoroHandleType = S.CheckTemplateIdType(
+      CXXScopeSpec(), TemplateName(CoroHandle), Loc, Args);
   if (CoroHandleType.isNull())
     return QualType();
   if (S.RequireCompleteType(Loc, CoroHandleType,
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -531,6 +531,8 @@
     DiagnoseUseOfDecl(IIDecl, NameLoc);
 
     T = Context.getTypeDeclType(TD);
+    if (SS && SS->isNotEmpty())
+      T = resugar(*SS, T);
     MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false);
   } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) {
     (void)DiagnoseUseOfDecl(IDecl, NameLoc);
@@ -12410,6 +12412,7 @@
     return true;
   }
 
+  // FIXME: Set TypeSourceInfo?
   VDecl->setType(DeducedType);
   assert(VDecl->isLinkageValid());
 
diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp
--- a/clang/lib/Sema/SemaDeclAttr.cpp
+++ b/clang/lib/Sema/SemaDeclAttr.cpp
@@ -3599,9 +3599,13 @@
       return;
     }
   } else if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
-    if (ULE->hasExplicitTemplateArgs())
+    if (ULE->hasExplicitTemplateArgs()) {
       S.Diag(Loc, diag::warn_cleanup_ext);
-    FD = S.ResolveSingleFunctionTemplateSpecialization(ULE, true);
+      TemplateArgumentListInfo ExplicitTemplateArgs;
+      ULE->copyTemplateArgumentsInto(ExplicitTemplateArgs);
+      FD = S.ResolveSingleFunctionTemplateSpecialization(
+          ULE, ExplicitTemplateArgs, /*Complain=*/true);
+    }
     NI = ULE->getNameInfo();
     if (!FD) {
       S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 2
@@ -3623,6 +3627,7 @@
 
   // We're currently more strict than GCC about what function types we accept.
   // If this ever proves to be a problem it should be easy to fix.
+  // FIXME: resugar
   QualType Ty = S.Context.getPointerType(cast<VarDecl>(D)->getType());
   QualType ParamTy = FD->getParamDecl(0)->getType();
   if (S.CheckAssignmentConstraints(FD->getParamDecl(0)->getLocation(),
diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp
--- a/clang/lib/Sema/SemaDeclCXX.cpp
+++ b/clang/lib/Sema/SemaDeclCXX.cpp
@@ -1032,7 +1032,8 @@
   }
 
   // Build the template-id.
-  QualType TraitTy = S.CheckTemplateIdType(TemplateName(TraitTD), Loc, Args);
+  QualType TraitTy =
+      S.CheckTemplateIdType(CXXScopeSpec(), TemplateName(TraitTD), Loc, Args);
   if (TraitTy.isNull())
     return true;
   if (!S.isCompleteType(Loc, TraitTy)) {
@@ -1402,6 +1403,9 @@
     if (FD->isUnnamedBitfield())
       continue;
 
+    // FIXME: Avoid having to recreate the naming context for every field.
+    QualType FieldType = S.resugar(DecompType.getTypePtr(), FD->getType());
+
     // All the non-static data members are required to be nameable, so they
     // must all have names.
     if (!FD->getDeclName()) {
@@ -1413,7 +1417,7 @@
 
       if (FD->isAnonymousStructOrUnion()) {
         S.Diag(Src->getLocation(), diag::err_decomp_decl_anon_union_member)
-          << DecompType << FD->getType()->isUnionType();
+            << DecompType << FieldType->isUnionType();
         S.Diag(FD->getLocation(), diag::note_declared_at);
         return true;
       }
@@ -1445,7 +1449,7 @@
     if (E.isInvalid())
       return true;
     E = S.BuildFieldReferenceExpr(E.get(), /*IsArrow*/ false, Loc,
-                                  CXXScopeSpec(), FD,
+                                  NestedNameSpecifierLoc(), FD, FieldType,
                                   DeclAccessPair::make(FD, FD->getAccess()),
                                   DeclarationNameInfo(FD->getDeclName(), Loc));
     if (E.isInvalid())
@@ -1459,7 +1463,7 @@
     Qualifiers Q = DecompType.getQualifiers();
     if (FD->isMutable())
       Q.removeConst();
-    B->setBinding(S.BuildQualifiedType(FD->getType(), Loc, Q), E.get());
+    B->setBinding(S.BuildQualifiedType(FieldType, Loc, Q), E.get());
   }
 
   if (I != Bindings.size())
@@ -8270,10 +8274,13 @@
 
     DeclAccessPair Found = DeclAccessPair::make(Field, Field->getAccess());
     DeclarationNameInfo NameInfo(Field->getDeclName(), Loc);
+    QualType FieldType = Field->getType();
     return {S.BuildFieldReferenceExpr(Obj.first.get(), /*IsArrow=*/false, Loc,
-                                      CXXScopeSpec(), Field, Found, NameInfo),
+                                      NestedNameSpecifierLoc(), Field,
+                                      FieldType, Found, NameInfo),
             S.BuildFieldReferenceExpr(Obj.second.get(), /*IsArrow=*/false, Loc,
-                                      CXXScopeSpec(), Field, Found, NameInfo)};
+                                      NestedNameSpecifierLoc(), Field,
+                                      FieldType, Found, NameInfo)};
   }
 
   // FIXME: When expanding a subobject, register a note in the code synthesis
@@ -11585,7 +11592,8 @@
   return Context.getElaboratedType(
       ElaboratedTypeKeyword::ETK_None,
       NestedNameSpecifier::Create(Context, nullptr, getStdNamespace()),
-      CheckTemplateIdType(TemplateName(StdInitializerList), Loc, Args));
+      CheckTemplateIdType(CXXScopeSpec(), TemplateName(StdInitializerList), Loc,
+                          Args));
 }
 
 bool Sema::isInitListConstructor(const FunctionDecl *Ctor) {
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -3307,6 +3307,8 @@
   QualType type = VD->getType();
   if (type.isNull())
     return ExprError();
+  type = TemplateArgs ? resugar(SS, VD, TemplateArgs->arguments(), type)
+                      : resugar(SS, type);
   ExprValueKind valueKind = VK_PRValue;
 
   // In 'T ...V;', the type of the declaration 'V' is 'T...', but the type of
@@ -9967,7 +9969,8 @@
     DeclAccessPair DAP;
     if (FunctionDecl *FD = ResolveAddressOfOverloadedFunction(
             RHS.get(), LHSType, /*Complain=*/false, DAP))
-      RHS = FixOverloadedFunctionReference(RHS.get(), DAP, FD);
+      // FIXME: resugar
+      RHS = FixOverloadedFunctionReference(RHS.get(), DAP, FD, nullptr);
     else
       return Incompatible;
   }
@@ -14258,14 +14261,18 @@
       }
 
       OverloadExpr *Ovl = cast<OverloadExpr>(E);
-      if (isa<UnresolvedMemberExpr>(Ovl))
-        if (!ResolveSingleFunctionTemplateSpecialization(Ovl)) {
-          Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
-            << OrigOp.get()->getSourceRange();
-          return QualType();
-        }
-
-      return Context.OverloadTy;
+      if (!isa<UnresolvedMemberExpr>(Ovl))
+        return Context.OverloadTy;
+      if (Ovl->hasExplicitTemplateArgs()) {
+        TemplateArgumentListInfo ExplicitTemplateArgs;
+        Ovl->copyTemplateArgumentsInto(ExplicitTemplateArgs);
+        if (ResolveSingleFunctionTemplateSpecialization(Ovl,
+                                                        ExplicitTemplateArgs))
+          return Context.OverloadTy;
+      }
+      Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
+          << OrigOp.get()->getSourceRange();
+      return QualType();
     }
 
     if (PTy->getKind() == BuiltinType::UnknownAny)
@@ -14371,8 +14378,24 @@
     if (isa<CXXDestructorDecl>(MD))
       Diag(OpLoc, diag::err_typecheck_addrof_dtor) << op->getSourceRange();
 
-    QualType MPTy = Context.getMemberPointerType(
-        op->getType(), Context.getTypeDeclType(MD->getParent()).getTypePtr());
+    const CXXRecordDecl *Cls = MD->getParent();
+    const Type *ClsType = nullptr;
+    if (const NestedNameSpecifier *NNS = DRE->getQualifier()) {
+      const Type *Type = NNS->getAsType();
+      const CXXRecordDecl *ClsAsWritten =
+          Type ? Type->getAsCXXRecordDecl() : NNS->getAsRecordDecl();
+      assert(ClsAsWritten != nullptr);
+      if (declaresSameEntity(Cls, ClsAsWritten))
+        ClsType =
+            Type ? Type : Context.getTypeDeclType(ClsAsWritten).getTypePtr();
+      else
+        // FIXME: Can we do better here?
+        assert(ClsAsWritten->isDerivedFrom(Cls));
+    }
+    if (!ClsType)
+      ClsType = Context.getTypeDeclType(Cls).getTypePtr();
+
+    QualType MPTy = Context.getMemberPointerType(op->getType(), ClsType);
     // Under the MS ABI, lock down the inheritance model now.
     if (Context.getTargetInfo().getCXXABI().isMicrosoft())
       (void)isCompleteType(OpLoc, MPTy);
@@ -19183,8 +19206,8 @@
           S.Context, Base.get(), ME->isArrow(), ME->getOperatorLoc(),
           ME->getQualifierLoc(), ME->getTemplateKeywordLoc(),
           ME->getMemberDecl(), ME->getFoundDecl(), ME->getMemberNameInfo(),
-          CopiedTemplateArgs(ME), ME->getType(), ME->getValueKind(),
-          ME->getObjectKind(), ME->isNonOdrUse());
+          CopiedTemplateArgs(ME), ME->getDeduced(), ME->getType(),
+          ME->getValueKind(), ME->getObjectKind(), ME->isNonOdrUse());
     }
 
     if (ME->getMemberDecl()->isCXXInstanceMember())
@@ -19201,7 +19224,8 @@
         S.Context, ME->getBase(), ME->isArrow(), ME->getOperatorLoc(),
         ME->getQualifierLoc(), ME->getTemplateKeywordLoc(), ME->getMemberDecl(),
         ME->getFoundDecl(), ME->getMemberNameInfo(), CopiedTemplateArgs(ME),
-        ME->getType(), ME->getValueKind(), ME->getObjectKind(), NOUR);
+        ME->getDeduced(), ME->getType(), ME->getValueKind(),
+        ME->getObjectKind(), NOUR);
   }
 
   case Expr::BinaryOperatorClass: {
@@ -19503,10 +19527,18 @@
 
         // Re-set the member to trigger a recomputation of the dependence bits
         // for the expression.
-        if (auto *DRE = dyn_cast_or_null<DeclRefExpr>(E))
+        CXXScopeSpec SS;
+        if (auto *DRE = dyn_cast_or_null<DeclRefExpr>(E)) {
           DRE->setDecl(DRE->getDecl());
-        else if (auto *ME = dyn_cast_or_null<MemberExpr>(E))
+          SS.Adopt(DRE->getQualifierLoc());
+          DRE->setType(SemaRef.resugar(
+              SS, DRE->getDecl(), DRE->template_arguments(), DRE->getType()));
+        } else if (auto *ME = dyn_cast_or_null<MemberExpr>(E)) {
           ME->setMemberDecl(ME->getMemberDecl());
+          SS.Adopt(ME->getQualifierLoc());
+          ME->setType(SemaRef.resugar(SS, ME->getMemberDecl(),
+                                      ME->template_arguments(), ME->getType()));
+        }
       } else if (FirstInstantiation ||
                  isa<VarTemplateSpecializationDecl>(Var)) {
         // FIXME: For a specialization of a variable template, we don't
@@ -20741,6 +20773,7 @@
         SS.Adopt(DRE->getQualifierLoc());
         TemplateArgumentListInfo TemplateArgs;
         DRE->copyTemplateArgumentsInto(TemplateArgs);
+        // FIXME: resugar
         return BuildDeclRefExpr(
             FD, FD->getType(), VK_LValue, DRE->getNameInfo(),
             DRE->hasQualifier() ? &SS : nullptr, DRE->getFoundDecl(),
diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp
--- a/clang/lib/Sema/SemaExprCXX.cpp
+++ b/clang/lib/Sema/SemaExprCXX.cpp
@@ -4250,7 +4250,8 @@
     if (DiagnoseUseOfDecl(Fn, From->getBeginLoc()))
       return ExprError();
 
-    From = FixOverloadedFunctionReference(From, Found, Fn);
+    // FIXME: resugar
+    From = FixOverloadedFunctionReference(From, Found, Fn, nullptr);
 
     // We might get back another placeholder expression if we resolved to a
     // builtin.
diff --git a/clang/lib/Sema/SemaExprMember.cpp b/clang/lib/Sema/SemaExprMember.cpp
--- a/clang/lib/Sema/SemaExprMember.cpp
+++ b/clang/lib/Sema/SemaExprMember.cpp
@@ -798,18 +798,14 @@
                                   false, ExtraArgs);
 }
 
-ExprResult
-Sema::BuildAnonymousStructUnionMemberReference(const CXXScopeSpec &SS,
-                                               SourceLocation loc,
-                                               IndirectFieldDecl *indirectField,
-                                               DeclAccessPair foundDecl,
-                                               Expr *baseObjectExpr,
-                                               SourceLocation opLoc) {
+ExprResult Sema::BuildAnonymousStructUnionMemberReference(
+    const CXXScopeSpec &SS, SourceLocation loc,
+    IndirectFieldDecl *indirectField, DeclAccessPair foundDecl,
+    Expr *baseObjectExpr, const Type *BaseType, SourceLocation opLoc) {
   // First, build the expression that refers to the base object.
 
   // Case 1:  the base of the indirect field is not a field.
   VarDecl *baseVariable = indirectField->getVarDecl();
-  CXXScopeSpec EmptySS;
   if (baseVariable) {
     assert(baseVariable->getType()->isRecordType());
 
@@ -822,6 +818,7 @@
 
     DeclarationNameInfo baseNameInfo(DeclarationName(), loc);
 
+    CXXScopeSpec EmptySS;
     ExprResult result
       = BuildDeclarationNameExpr(EmptySS, baseNameInfo, baseVariable);
     if (result.isInvalid()) return ExprError();
@@ -839,6 +836,8 @@
   IndirectFieldDecl::chain_iterator
   FI = indirectField->chain_begin(), FEnd = indirectField->chain_end();
 
+  NestedNameSpecifierLoc NNS = SS.getWithLocInContext(Context);
+
   // Case 2: the base of the indirect field is a field and the user
   // wrote a member expression.
   if (!baseVariable) {
@@ -849,11 +848,15 @@
     // Make a nameInfo that properly uses the anonymous name.
     DeclarationNameInfo memberNameInfo(field->getDeclName(), loc);
 
+    // FIXME: Avoid redundant setting of the naming scope with the loop below.
+    QualType FieldType =
+        BaseType ? resugar(BaseType, NNS, field->getType()) : field->getType();
+
     // Build the first member access in the chain with full information.
-    result =
-        BuildFieldReferenceExpr(result, baseObjectIsPointer, SourceLocation(),
-                                SS, field, foundDecl, memberNameInfo)
-            .get();
+    result = BuildFieldReferenceExpr(result, baseObjectIsPointer,
+                                     SourceLocation(), NNS, field, FieldType,
+                                     foundDecl, memberNameInfo)
+                 .get();
     if (!result)
       return ExprError();
   }
@@ -869,10 +872,14 @@
     DeclAccessPair fakeFoundDecl =
         DeclAccessPair::make(field, field->getAccess());
 
+    QualType FieldType = BaseType && FI == FEnd
+                             ? resugar(BaseType, NNS, field->getType())
+                             : field->getType();
+
     result =
         BuildFieldReferenceExpr(result, /*isarrow*/ false, SourceLocation(),
-                                (FI == FEnd ? SS : EmptySS), field,
-                                fakeFoundDecl, memberNameInfo)
+                                (FI == FEnd ? NNS : NestedNameSpecifierLoc()),
+                                field, FieldType, fakeFoundDecl, memberNameInfo)
             .get();
   }
 
@@ -897,12 +904,13 @@
     SourceLocation TemplateKWLoc, ValueDecl *Member, DeclAccessPair FoundDecl,
     bool HadMultipleCandidates, const DeclarationNameInfo &MemberNameInfo,
     QualType Ty, ExprValueKind VK, ExprObjectKind OK,
-    const TemplateArgumentListInfo *TemplateArgs) {
+    const TemplateArgumentListInfo *TemplateArgs,
+    const TemplateArgumentList *Deduced) {
   NestedNameSpecifierLoc NNS =
       SS ? SS->getWithLocInContext(Context) : NestedNameSpecifierLoc();
   return BuildMemberExpr(Base, IsArrow, OpLoc, NNS, TemplateKWLoc, Member,
                          FoundDecl, HadMultipleCandidates, MemberNameInfo, Ty,
-                         VK, OK, TemplateArgs);
+                         VK, OK, TemplateArgs, Deduced);
 }
 
 MemberExpr *Sema::BuildMemberExpr(
@@ -910,13 +918,14 @@
     SourceLocation TemplateKWLoc, ValueDecl *Member, DeclAccessPair FoundDecl,
     bool HadMultipleCandidates, const DeclarationNameInfo &MemberNameInfo,
     QualType Ty, ExprValueKind VK, ExprObjectKind OK,
-    const TemplateArgumentListInfo *TemplateArgs) {
+    const TemplateArgumentListInfo *TemplateArgs,
+    const TemplateArgumentList *Deduced) {
   assert((!IsArrow || Base->isPRValue()) &&
          "-> base must be a pointer prvalue");
-  MemberExpr *E =
-      MemberExpr::Create(Context, Base, IsArrow, OpLoc, NNS, TemplateKWLoc,
-                         Member, FoundDecl, MemberNameInfo, TemplateArgs, Ty,
-                         VK, OK, getNonOdrUseReasonInCurrentContext(Member));
+  MemberExpr *E = MemberExpr::Create(
+      Context, Base, IsArrow, OpLoc, NNS, TemplateKWLoc, Member, FoundDecl,
+      MemberNameInfo, TemplateArgs, Deduced, Ty, VK, OK,
+      getNonOdrUseReasonInCurrentContext(Member));
   E->setHadMultipleCandidates(HadMultipleCandidates);
   MarkMemberReferenced(E);
 
@@ -1094,29 +1103,41 @@
   if (DiagnoseUseOfDecl(MemberDecl, MemberLoc))
     return ExprError();
 
-  if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl))
-    return BuildFieldReferenceExpr(BaseExpr, IsArrow, OpLoc, SS, FD, FoundDecl,
-                                   MemberNameInfo);
+  if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl)) {
+    assert(!TemplateArgs);
+    NestedNameSpecifierLoc NNS = SS.getWithLocInContext(Context);
+    QualType FieldType = resugar(BaseType.getTypePtr(), NNS, FD->getType());
+    // null
+    //        in case of implicit access.
+    return BuildFieldReferenceExpr(BaseExpr, IsArrow, OpLoc, NNS, FD, FieldType,
+                                   FoundDecl, MemberNameInfo);
+  }
 
   if (MSPropertyDecl *PD = dyn_cast<MSPropertyDecl>(MemberDecl))
+    // FIXME: resugar these.
     return BuildMSPropertyRefExpr(*this, BaseExpr, IsArrow, SS, PD,
                                   MemberNameInfo);
 
   if (IndirectFieldDecl *FD = dyn_cast<IndirectFieldDecl>(MemberDecl))
     // We may have found a field within an anonymous union or struct
     // (C++ [class.union]).
-    return BuildAnonymousStructUnionMemberReference(SS, MemberLoc, FD,
-                                                    FoundDecl, BaseExpr,
-                                                    OpLoc);
+    return BuildAnonymousStructUnionMemberReference(
+        SS, MemberLoc, FD, FoundDecl, BaseExpr, BaseType.getTypePtr(), OpLoc);
 
   if (VarDecl *Var = dyn_cast<VarDecl>(MemberDecl)) {
-    return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Var,
+    assert(!TemplateArgs);
+    NestedNameSpecifierLoc NNS = SS.getWithLocInContext(Context);
+    QualType VarType = resugar(BaseType.getTypePtr(), NNS, Var->getType());
+    return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, NNS, TemplateKWLoc, Var,
                            FoundDecl, /*HadMultipleCandidates=*/false,
-                           MemberNameInfo, Var->getType().getNonReferenceType(),
+                           MemberNameInfo, VarType.getNonReferenceType(),
                            VK_LValue, OK_Ordinary);
   }
 
   if (CXXMethodDecl *MemberFn = dyn_cast<CXXMethodDecl>(MemberDecl)) {
+    assert(!TemplateArgs);
+    NestedNameSpecifierLoc NNS = SS.getWithLocInContext(Context);
+
     ExprValueKind valueKind;
     QualType type;
     if (MemberFn->isInstance()) {
@@ -1124,20 +1145,23 @@
       type = Context.BoundMemberTy;
     } else {
       valueKind = VK_LValue;
-      type = MemberFn->getType();
+      type = resugar(BaseType.getTypePtr(), NNS, MemberFn->getType());
     }
 
-    return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc,
+    return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, NNS, TemplateKWLoc,
                            MemberFn, FoundDecl, /*HadMultipleCandidates=*/false,
                            MemberNameInfo, type, valueKind, OK_Ordinary);
   }
   assert(!isa<FunctionDecl>(MemberDecl) && "member function not C++ method?");
 
   if (EnumConstantDecl *Enum = dyn_cast<EnumConstantDecl>(MemberDecl)) {
-    return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Enum,
+    assert(!TemplateArgs);
+    NestedNameSpecifierLoc NNS = SS.getWithLocInContext(Context);
+    // FIXME: EnumType resugaring not implemented.
+    QualType EnumType = resugar(BaseType.getTypePtr(), NNS, Enum->getType());
+    return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, NNS, TemplateKWLoc, Enum,
                            FoundDecl, /*HadMultipleCandidates=*/false,
-                           MemberNameInfo, Enum->getType(), VK_PRValue,
-                           OK_Ordinary);
+                           MemberNameInfo, EnumType, VK_PRValue, OK_Ordinary);
   }
 
   if (VarTemplateDecl *VarTempl = dyn_cast<VarTemplateDecl>(MemberDecl)) {
@@ -1161,10 +1185,13 @@
     if (!Var->getTemplateSpecializationKind())
       Var->setTemplateSpecializationKind(TSK_ImplicitInstantiation, MemberLoc);
 
+    NestedNameSpecifierLoc NNS = SS.getWithLocInContext(Context);
+    QualType VarType = resugar(BaseType.getTypePtr(), NNS, Var,
+                               TemplateArgs->arguments(), Var->getType());
     return BuildMemberExpr(
-        BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Var, FoundDecl,
+        BaseExpr, IsArrow, OpLoc, NNS, TemplateKWLoc, Var, FoundDecl,
         /*HadMultipleCandidates=*/false, MemberNameInfo,
-        Var->getType().getNonReferenceType(), VK_LValue, OK_Ordinary);
+        VarType.getNonReferenceType(), VK_LValue, OK_Ordinary);
   }
 
   // We found something that we didn't expect. Complain.
@@ -1796,11 +1823,10 @@
   }
 }
 
-ExprResult
-Sema::BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow,
-                              SourceLocation OpLoc, const CXXScopeSpec &SS,
-                              FieldDecl *Field, DeclAccessPair FoundDecl,
-                              const DeclarationNameInfo &MemberNameInfo) {
+ExprResult Sema::BuildFieldReferenceExpr(
+    Expr *BaseExpr, bool IsArrow, SourceLocation OpLoc,
+    const NestedNameSpecifierLoc &NNS, FieldDecl *Field, QualType FieldType,
+    DeclAccessPair FoundDecl, const DeclarationNameInfo &MemberNameInfo) {
   // x.a is an l-value if 'a' has a reference type. Otherwise:
   // x.a is an l-value/x-value/pr-value if the base is (and note
   //   that *x is always an l-value), except that if the base isn't
@@ -1817,9 +1843,8 @@
     OK = OK_BitField;
 
   // Figure out the type of the member; see C99 6.5.2.3p3, C++ [expr.ref]
-  QualType MemberType = Field->getType();
-  if (const ReferenceType *Ref = MemberType->getAs<ReferenceType>()) {
-    MemberType = Ref->getPointeeType();
+  if (const ReferenceType *Ref = FieldType->getAs<ReferenceType>()) {
+    FieldType = Ref->getPointeeType();
     VK = VK_LValue;
   } else {
     QualType BaseType = BaseExpr->getType();
@@ -1835,29 +1860,29 @@
     if (Field->isMutable()) BaseQuals.removeConst();
 
     Qualifiers MemberQuals =
-        Context.getCanonicalType(MemberType).getQualifiers();
+        Context.getCanonicalType(FieldType).getQualifiers();
 
     assert(!MemberQuals.hasAddressSpace());
 
     Qualifiers Combined = BaseQuals + MemberQuals;
     if (Combined != MemberQuals)
-      MemberType = Context.getQualifiedType(MemberType, Combined);
+      FieldType = Context.getQualifiedType(FieldType, Combined);
 
     // Pick up NoDeref from the base in case we end up using AddrOf on the
     // result. E.g. the expression
     //     &someNoDerefPtr->pointerMember
     // should be a noderef pointer again.
     if (BaseType->hasAttr(attr::NoDeref))
-      MemberType =
-          Context.getAttributedType(attr::NoDeref, MemberType, MemberType);
+      FieldType =
+          Context.getAttributedType(attr::NoDeref, FieldType, FieldType);
   }
 
   auto *CurMethod = dyn_cast<CXXMethodDecl>(CurContext);
   if (!(CurMethod && CurMethod->isDefaulted()))
     UnusedPrivateFields.remove(Field);
 
-  ExprResult Base = PerformObjectMemberConversion(BaseExpr, SS.getScopeRep(),
-                                                  FoundDecl, Field);
+  ExprResult Base = PerformObjectMemberConversion(
+      BaseExpr, NNS.getNestedNameSpecifier(), FoundDecl, Field);
   if (Base.isInvalid())
     return ExprError();
 
@@ -1872,10 +1897,10 @@
     }
   }
 
-  return BuildMemberExpr(Base.get(), IsArrow, OpLoc, &SS,
+  return BuildMemberExpr(Base.get(), IsArrow, OpLoc, NNS,
                          /*TemplateKWLoc=*/SourceLocation(), Field, FoundDecl,
                          /*HadMultipleCandidates=*/false, MemberNameInfo,
-                         MemberType, VK, OK);
+                         FieldType, VK, OK);
 }
 
 /// Builds an implicit member access expression.  The current context
diff --git a/clang/lib/Sema/SemaInit.cpp b/clang/lib/Sema/SemaInit.cpp
--- a/clang/lib/Sema/SemaInit.cpp
+++ b/clang/lib/Sema/SemaInit.cpp
@@ -8261,9 +8261,9 @@
       S.CheckAddressOfMemberAccess(CurInit.get(), Step->Function.FoundDecl);
       if (S.DiagnoseUseOfDecl(Step->Function.FoundDecl, Kind.getLocation()))
         return ExprError();
-      CurInit = S.FixOverloadedFunctionReference(CurInit,
-                                                 Step->Function.FoundDecl,
-                                                 Step->Function.Function);
+      // FIXME: resugar
+      CurInit = S.FixOverloadedFunctionReference(
+          CurInit, Step->Function.FoundDecl, Step->Function.Function, nullptr);
       // We might get back another placeholder expression if we resolved to a
       // builtin.
       if (!CurInit.isInvalid())
@@ -10289,12 +10289,13 @@
     MarkFunctionReferenced(Kind.getLocation(), Best->Function);
     break;
   }
+  QualType RT = Best->Function->getReturnType();
+  // FIXME: resugar here
 
   // C++ [dcl.type.class.deduct]p1:
   //  The placeholder is replaced by the return type of the function selected
   //  by overload resolution for class template deduction.
-  QualType DeducedType =
-      SubstAutoType(TSInfo->getType(), Best->Function->getReturnType());
+  QualType DeducedType = SubstAutoType(TSInfo->getType(), RT);
   Diag(TSInfo->getTypeLoc().getBeginLoc(),
        diag::warn_cxx14_compat_class_template_argument_deduction)
       << TSInfo->getTypeLoc().getSourceRange() << 1 << DeducedType;
diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp
--- a/clang/lib/Sema/SemaOverload.cpp
+++ b/clang/lib/Sema/SemaOverload.cpp
@@ -5691,9 +5691,6 @@
                                                    Sema::CCEKind CCE,
                                                    bool RequireInt,
                                                    NamedDecl *Dest) {
-  assert(S.getLangOpts().CPlusPlus11 &&
-         "converted constant expression outside C++11");
-
   if (checkPlaceholderForOverload(S, From))
     return ExprError();
 
@@ -6332,7 +6329,7 @@
     OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
     bool PartialOverloading, bool AllowExplicit, bool AllowExplicitConversions,
     ADLCallKind IsADLCandidate, ConversionSequenceList EarlyConversions,
-    OverloadCandidateParamOrder PO) {
+    OverloadCandidateParamOrder PO, const TemplateArgumentList *Deduced) {
   const FunctionProtoType *Proto
     = dyn_cast<FunctionProtoType>(Function->getType()->getAs<FunctionType>());
   assert(Proto && "Functions without a prototype cannot be overloaded");
@@ -6351,7 +6348,7 @@
       AddMethodCandidate(Method, FoundDecl, Method->getParent(), QualType(),
                          Expr::Classification::makeSimpleLValue(), Args,
                          CandidateSet, SuppressUserConversions,
-                         PartialOverloading, EarlyConversions, PO);
+                         PartialOverloading, EarlyConversions, PO, Deduced);
       return;
     }
     // We treat a constructor like a non-member function, since its object
@@ -6396,6 +6393,7 @@
   Candidate.IsADLCandidate = IsADLCandidate;
   Candidate.IgnoreObjectArgument = false;
   Candidate.ExplicitCallArguments = Args.size();
+  Candidate.Deduced = Deduced;
 
   // Explicit functions are not actually candidates at all if we're not
   // allowing them in this context, but keep them around so we can point
@@ -6930,16 +6928,13 @@
 /// both @c a1 and @c a2. If @p SuppressUserConversions, then don't
 /// allow user-defined conversions via constructors or conversion
 /// operators.
-void
-Sema::AddMethodCandidate(CXXMethodDecl *Method, DeclAccessPair FoundDecl,
-                         CXXRecordDecl *ActingContext, QualType ObjectType,
-                         Expr::Classification ObjectClassification,
-                         ArrayRef<Expr *> Args,
-                         OverloadCandidateSet &CandidateSet,
-                         bool SuppressUserConversions,
-                         bool PartialOverloading,
-                         ConversionSequenceList EarlyConversions,
-                         OverloadCandidateParamOrder PO) {
+void Sema::AddMethodCandidate(
+    CXXMethodDecl *Method, DeclAccessPair FoundDecl,
+    CXXRecordDecl *ActingContext, QualType ObjectType,
+    Expr::Classification ObjectClassification, ArrayRef<Expr *> Args,
+    OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
+    bool PartialOverloading, ConversionSequenceList EarlyConversions,
+    OverloadCandidateParamOrder PO, const TemplateArgumentList *Deduced) {
   const FunctionProtoType *Proto
     = dyn_cast<FunctionProtoType>(Method->getType()->getAs<FunctionType>());
   assert(Proto && "Methods without a prototype cannot be overloaded");
@@ -6970,6 +6965,7 @@
   Candidate.IsSurrogate = false;
   Candidate.IgnoreObjectArgument = false;
   Candidate.ExplicitCallArguments = Args.size();
+  Candidate.Deduced = Deduced;
 
   unsigned NumParams = Proto->getNumParams();
 
@@ -7146,7 +7142,7 @@
   AddMethodCandidate(cast<CXXMethodDecl>(Specialization), FoundDecl,
                      ActingContext, ObjectType, ObjectClassification, Args,
                      CandidateSet, SuppressUserConversions, PartialOverloading,
-                     Conversions, PO);
+                     Conversions, PO, Info.takeSugared());
 }
 
 /// Determine whether a given function template has a simple explicit specifier
@@ -7226,10 +7222,11 @@
   // Add the function template specialization produced by template argument
   // deduction as a candidate.
   assert(Specialization && "Missing function template specialization?");
-  AddOverloadCandidate(
-      Specialization, FoundDecl, Args, CandidateSet, SuppressUserConversions,
-      PartialOverloading, AllowExplicit,
-      /*AllowExplicitConversions*/ false, IsADLCandidate, Conversions, PO);
+  AddOverloadCandidate(Specialization, FoundDecl, Args, CandidateSet,
+                       SuppressUserConversions, PartialOverloading,
+                       AllowExplicit,
+                       /*AllowExplicitConversions*/ false, IsADLCandidate,
+                       Conversions, PO, Info.takeSugared());
 }
 
 /// Check that implicit conversion sequences can be formed for each argument
@@ -12075,15 +12072,20 @@
         FailedCandidates(OvlExpr->getNameLoc(), /*ForTakingAddress=*/true) {
     ExtractUnqualifiedFunctionTypeFromTargetType();
 
+    if (OvlExpr->hasExplicitTemplateArgs())
+      OvlExpr->copyTemplateArgumentsInto(OvlExplicitTemplateArgs);
+
     if (TargetFunctionType->isFunctionType()) {
       if (UnresolvedMemberExpr *UME = dyn_cast<UnresolvedMemberExpr>(OvlExpr))
         if (!UME->isImplicitAccess() &&
-            !S.ResolveSingleFunctionTemplateSpecialization(UME))
+            (!OvlExpr->hasExplicitTemplateArgs() ||
+             !S.ResolveSingleFunctionTemplateSpecialization(
+                 UME, OvlExplicitTemplateArgs)))
           StaticMemberFunctionFromBoundPointer = true;
     } else if (OvlExpr->hasExplicitTemplateArgs()) {
       DeclAccessPair dap;
       if (FunctionDecl *Fn = S.ResolveSingleFunctionTemplateSpecialization(
-              OvlExpr, false, &dap)) {
+              OvlExpr, OvlExplicitTemplateArgs, /*Complain=*/false, &dap)) {
         if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn))
           if (!Method->isStatic()) {
             // If the target type is a non-function type and the function found
@@ -12102,9 +12104,6 @@
       return;
     }
 
-    if (OvlExpr->hasExplicitTemplateArgs())
-      OvlExpr->copyTemplateArgumentsInto(OvlExplicitTemplateArgs);
-
     if (FindAllFunctionsThatMatchTargetTypeExactly()) {
       // C++ [over.over]p4:
       //   If more than one function is selected, [...]
@@ -12590,7 +12589,8 @@
   // for both.
   DiagnoseUseOfDecl(Found, E->getExprLoc());
   CheckAddressOfMemberAccess(E, DAP);
-  Expr *Fixed = FixOverloadedFunctionReference(E, DAP, Found);
+  // FIXME: resugar
+  Expr *Fixed = FixOverloadedFunctionReference(E, DAP, Found, nullptr);
   if (DoFunctionPointerConversion && Fixed->getType()->isFunctionType())
     SrcExpr = DefaultFunctionArrayConversion(Fixed, /*Diagnose=*/false);
   else
@@ -12608,10 +12608,9 @@
 ///
 /// If no template-ids are found, no diagnostics are emitted and NULL is
 /// returned.
-FunctionDecl *
-Sema::ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl,
-                                                  bool Complain,
-                                                  DeclAccessPair *FoundResult) {
+FunctionDecl *Sema::ResolveSingleFunctionTemplateSpecialization(
+    OverloadExpr *ovl, TemplateArgumentListInfo &ExplicitTemplateArgs,
+    bool Complain, DeclAccessPair *FoundResult) {
   // C++ [over.over]p1:
   //   [...] [Note: any redundant set of parentheses surrounding the
   //   overloaded function name is ignored (5.1). ]
@@ -12619,12 +12618,9 @@
   //   [...] The overloaded function name can be preceded by the &
   //   operator.
 
-  // If we didn't actually find any template-ids, we're done.
-  if (!ovl->hasExplicitTemplateArgs())
-    return nullptr;
+  // Specializations must have template args.
+  assert(ovl->hasExplicitTemplateArgs());
 
-  TemplateArgumentListInfo ExplicitTemplateArgs;
-  ovl->copyTemplateArgumentsInto(ExplicitTemplateArgs);
   TemplateSpecCandidateSet FailedCandidates(ovl->getNameLoc());
 
   // Look through all of the overloaded functions, searching for one
@@ -12699,50 +12695,54 @@
   assert(SrcExpr.get()->getType() == Context.OverloadTy);
 
   OverloadExpr::FindResult ovl = OverloadExpr::find(SrcExpr.get());
-
-  DeclAccessPair found;
   ExprResult SingleFunctionExpression;
-  if (FunctionDecl *fn = ResolveSingleFunctionTemplateSpecialization(
-                           ovl.Expression, /*complain*/ false, &found)) {
-    if (DiagnoseUseOfDecl(fn, SrcExpr.get()->getBeginLoc())) {
-      SrcExpr = ExprError();
-      return true;
-    }
+  if (ovl.Expression->hasExplicitTemplateArgs()) {
+    TemplateArgumentListInfo ExplicitTemplateArgs;
+    ovl.Expression->copyTemplateArgumentsInto(ExplicitTemplateArgs);
+
+    DeclAccessPair found;
+    if (FunctionDecl *fn = ResolveSingleFunctionTemplateSpecialization(
+            ovl.Expression, ExplicitTemplateArgs, /*Complain=*/false, &found)) {
+      if (DiagnoseUseOfDecl(fn, SrcExpr.get()->getBeginLoc())) {
+        SrcExpr = ExprError();
+        return true;
+      }
 
-    // It is only correct to resolve to an instance method if we're
-    // resolving a form that's permitted to be a pointer to member.
-    // Otherwise we'll end up making a bound member expression, which
-    // is illegal in all the contexts we resolve like this.
-    if (!ovl.HasFormOfMemberPointer &&
-        isa<CXXMethodDecl>(fn) &&
-        cast<CXXMethodDecl>(fn)->isInstance()) {
-      if (!complain) return false;
-
-      Diag(ovl.Expression->getExprLoc(),
-           diag::err_bound_member_function)
-        << 0 << ovl.Expression->getSourceRange();
-
-      // TODO: I believe we only end up here if there's a mix of
-      // static and non-static candidates (otherwise the expression
-      // would have 'bound member' type, not 'overload' type).
-      // Ideally we would note which candidate was chosen and why
-      // the static candidates were rejected.
-      SrcExpr = ExprError();
-      return true;
-    }
+      // It is only correct to resolve to an instance method if we're
+      // resolving a form that's permitted to be a pointer to member.
+      // Otherwise we'll end up making a bound member expression, which
+      // is illegal in all the contexts we resolve like this.
+      if (!ovl.HasFormOfMemberPointer && isa<CXXMethodDecl>(fn) &&
+          cast<CXXMethodDecl>(fn)->isInstance()) {
+        if (!complain)
+          return false;
 
-    // Fix the expression to refer to 'fn'.
-    SingleFunctionExpression =
-        FixOverloadedFunctionReference(SrcExpr.get(), found, fn);
+        Diag(ovl.Expression->getExprLoc(), diag::err_bound_member_function)
+            << 0 << ovl.Expression->getSourceRange();
 
-    // If desired, do function-to-pointer decay.
-    if (doFunctionPointerConversion) {
-      SingleFunctionExpression =
-        DefaultFunctionArrayLvalueConversion(SingleFunctionExpression.get());
-      if (SingleFunctionExpression.isInvalid()) {
+        // TODO: I believe we only end up here if there's a mix of
+        // static and non-static candidates (otherwise the expression
+        // would have 'bound member' type, not 'overload' type).
+        // Ideally we would note which candidate was chosen and why
+        // the static candidates were rejected.
         SrcExpr = ExprError();
         return true;
       }
+
+      // Fix the expression to refer to 'fn'.
+      // FIXME: resugar
+      SingleFunctionExpression =
+          FixOverloadedFunctionReference(SrcExpr.get(), found, fn, nullptr);
+
+      // If desired, do function-to-pointer decay.
+      if (doFunctionPointerConversion) {
+        SingleFunctionExpression = DefaultFunctionArrayLvalueConversion(
+            SingleFunctionExpression.get());
+        if (SingleFunctionExpression.isInvalid()) {
+          SrcExpr = ExprError();
+          return true;
+        }
+      }
     }
   }
 
@@ -13255,7 +13255,8 @@
     SemaRef.CheckUnresolvedLookupAccess(ULE, (*Best)->FoundDecl);
     if (SemaRef.DiagnoseUseOfDecl(FDecl, ULE->getNameLoc()))
       return ExprError();
-    Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
+    Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl,
+                                                (*Best)->Deduced);
     return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc,
                                          ExecConfig, /*IsExecConfig=*/false,
                                          (*Best)->IsADLCandidate);
@@ -13313,7 +13314,8 @@
     // We emitted an error for the unavailable/deleted function call but keep
     // the call in the AST.
     FunctionDecl *FDecl = (*Best)->Function;
-    Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
+    Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl,
+                                                (*Best)->Deduced);
     return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc,
                                          ExecConfig, /*IsExecConfig=*/false,
                                          (*Best)->IsADLCandidate);
@@ -14581,7 +14583,8 @@
     if (!Succeeded)
       return BuildRecoveryExpr(chooseRecoveryType(CandidateSet, &Best));
 
-    MemExprE = FixOverloadedFunctionReference(MemExprE, FoundDecl, Method);
+    MemExprE = FixOverloadedFunctionReference(MemExprE, FoundDecl, Method,
+                                              Best->Deduced);
 
     // If overload resolution picked a static member, build a
     // non-member call based on that function.
@@ -14592,20 +14595,34 @@
 
     MemExpr = cast<MemberExpr>(MemExprE->IgnoreParens());
   }
+  assert(Method && "Member call to something that isn't a method?");
 
-  QualType ResultType = Method->getReturnType();
-  ExprValueKind VK = Expr::getValueKindForType(ResultType);
-  ResultType = ResultType.getNonLValueExprType(Context);
+  QualType MethodType;
+  {
+    QualType BaseType = MemExpr->getBase()->getType();
+    if (MemExpr->isArrow())
+      BaseType = BaseType->castAs<PointerType>()->getPointeeType();
+    NestedNameSpecifierLoc NNS = MemExpr->getQualifierLoc();
+    // FIXME: Should we resugar the explicit template arguments as well?
+    const TemplateArgumentList *Deduced = MemExpr->getDeduced();
+    MethodType = Deduced
+                     ? resugar(BaseType.getTypePtr(), NNS, Method,
+                               Deduced->asArray(), Method->getType())
+                     : resugar(BaseType.getTypePtr(), NNS, Method->getType());
+  }
+
+  const auto *Proto = MethodType->castAs<FunctionProtoType>();
+  QualType ReturnType = Proto->getReturnType();
+
+  ExprValueKind VK = Expr::getValueKindForType(ReturnType);
+  QualType ResultType = ReturnType.getNonLValueExprType(Context);
 
-  assert(Method && "Member call to something that isn't a method?");
-  const auto *Proto = Method->getType()->castAs<FunctionProtoType>();
   CXXMemberCallExpr *TheCall = CXXMemberCallExpr::Create(
       Context, MemExprE, Args, ResultType, VK, RParenLoc,
       CurFPFeatureOverrides(), Proto->getNumParams());
 
   // Check for a valid return type.
-  if (CheckCallReturnType(Method->getReturnType(), MemExpr->getMemberLoc(),
-                          TheCall, Method))
+  if (CheckCallReturnType(ReturnType, MemExpr->getMemberLoc(), TheCall, Method))
     return BuildRecoveryExpr(ResultType);
 
   // Convert the object argument (for a non-static member function call).
@@ -15196,11 +15213,13 @@
 /// perhaps a '&' around it). We have resolved the overloaded function
 /// to the function declaration Fn, so patch up the expression E to
 /// refer (possibly indirectly) to Fn. Returns the new expr.
-Expr *Sema::FixOverloadedFunctionReference(Expr *E, DeclAccessPair Found,
-                                           FunctionDecl *Fn) {
+Expr *
+Sema::FixOverloadedFunctionReference(Expr *E, DeclAccessPair Found,
+                                     FunctionDecl *Fn,
+                                     const TemplateArgumentList *Deduced) {
   if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
-    Expr *SubExpr = FixOverloadedFunctionReference(PE->getSubExpr(),
-                                                   Found, Fn);
+    Expr *SubExpr =
+        FixOverloadedFunctionReference(PE->getSubExpr(), Found, Fn, Deduced);
     if (SubExpr == PE->getSubExpr())
       return PE;
 
@@ -15208,8 +15227,8 @@
   }
 
   if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
-    Expr *SubExpr = FixOverloadedFunctionReference(ICE->getSubExpr(),
-                                                   Found, Fn);
+    Expr *SubExpr =
+        FixOverloadedFunctionReference(ICE->getSubExpr(), Found, Fn, Deduced);
     assert(Context.hasSameType(ICE->getSubExpr()->getType(),
                                SubExpr->getType()) &&
            "Implicit cast type cannot be determined from overload");
@@ -15224,8 +15243,8 @@
 
   if (auto *GSE = dyn_cast<GenericSelectionExpr>(E)) {
     if (!GSE->isResultDependent()) {
-      Expr *SubExpr =
-          FixOverloadedFunctionReference(GSE->getResultExpr(), Found, Fn);
+      Expr *SubExpr = FixOverloadedFunctionReference(GSE->getResultExpr(),
+                                                     Found, Fn, Deduced);
       if (SubExpr == GSE->getResultExpr())
         return GSE;
 
@@ -15259,7 +15278,7 @@
         // UnresolvedLookupExpr holding an overloaded member function
         // or template.
         Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(),
-                                                       Found, Fn);
+                                                       Found, Fn, Deduced);
         if (SubExpr == UnOp->getSubExpr())
           return UnOp;
 
@@ -15271,10 +15290,14 @@
         // We have taken the address of a pointer to member
         // function. Perform the computation here so that we get the
         // appropriate pointer to member type.
+        // FIXME: get sugared class type
         QualType ClassType
           = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
-        QualType MemPtrType
-          = Context.getMemberPointerType(Fn->getType(), ClassType.getTypePtr());
+        QualType Type = Deduced ? resugar(CXXScopeSpec(), Fn,
+                                          Deduced->asArray(), Fn->getType())
+                                : resugar(CXXScopeSpec(), Fn->getType());
+        QualType MemPtrType =
+            Context.getMemberPointerType(Type, ClassType.getTypePtr());
         // Under the MS ABI, lock down the inheritance model now.
         if (Context.getTargetInfo().getCXXABI().isMicrosoft())
           (void)isCompleteType(UnOp->getOperatorLoc(), MemPtrType);
@@ -15284,8 +15307,8 @@
             UnOp->getOperatorLoc(), false, CurFPFeatureOverrides());
       }
     }
-    Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(),
-                                                   Found, Fn);
+    Expr *SubExpr =
+        FixOverloadedFunctionReference(UnOp->getSubExpr(), Found, Fn, Deduced);
     if (SubExpr == UnOp->getSubExpr())
       return UnOp;
 
@@ -15301,21 +15324,28 @@
       ULE->copyTemplateArgumentsInto(TemplateArgsBuffer);
       TemplateArgs = &TemplateArgsBuffer;
     }
+    NestedNameSpecifierLoc NNS = ULE->getQualifierLoc();
 
-    QualType Type = Fn->getType();
     ExprValueKind ValueKind = getLangOpts().CPlusPlus ? VK_LValue : VK_PRValue;
 
     // FIXME: Duplicated from BuildDeclarationNameExpr.
-    if (unsigned BID = Fn->getBuiltinID()) {
-      if (!Context.BuiltinInfo.isDirectlyAddressable(BID)) {
+    QualType Type;
+    {
+      unsigned BID = Fn->getBuiltinID();
+      if (BID && !Context.BuiltinInfo.isDirectlyAddressable(BID)) {
         Type = Context.BuiltinFnTy;
         ValueKind = VK_PRValue;
+      } else {
+        CXXScopeSpec SS;
+        SS.Adopt(NNS);
+        Type = Deduced ? resugar(SS, Fn, Deduced->asArray(), Fn->getType())
+                       : resugar(SS, Fn->getType());
       }
     }
 
     DeclRefExpr *DRE = BuildDeclRefExpr(
-        Fn, Type, ValueKind, ULE->getNameInfo(), ULE->getQualifierLoc(),
-        Found.getDecl(), ULE->getTemplateKeywordLoc(), TemplateArgs);
+        Fn, Type, ValueKind, ULE->getNameInfo(), NNS, Found.getDecl(),
+        ULE->getTemplateKeywordLoc(), TemplateArgs);
     DRE->setHadMultipleCandidates(ULE->getNumDecls() > 1);
     return DRE;
   }
@@ -15327,6 +15357,10 @@
       MemExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
       TemplateArgs = &TemplateArgsBuffer;
     }
+    QualType BaseType = MemExpr->getBaseType();
+    const Type *BasePointeeType = BaseType->getPointeeType().getTypePtrOrNull();
+    if (!BasePointeeType)
+      BasePointeeType = BaseType.getTypePtr();
 
     Expr *Base;
 
@@ -15334,46 +15368,51 @@
     // implicit member access, rewrite to a simple decl ref.
     if (MemExpr->isImplicitAccess()) {
       if (cast<CXXMethodDecl>(Fn)->isStatic()) {
-        DeclRefExpr *DRE = BuildDeclRefExpr(
-            Fn, Fn->getType(), VK_LValue, MemExpr->getNameInfo(),
-            MemExpr->getQualifierLoc(), Found.getDecl(),
-            MemExpr->getTemplateKeywordLoc(), TemplateArgs);
+        QualType Type = Deduced ? resugar(BasePointeeType, Fn,
+                                          Deduced->asArray(), Fn->getType())
+                                : resugar(BasePointeeType, Fn->getType());
+        DeclRefExpr *DRE =
+            BuildDeclRefExpr(Fn, Type, VK_LValue, MemExpr->getNameInfo(),
+                             MemExpr->getQualifierLoc(), Found.getDecl(),
+                             MemExpr->getTemplateKeywordLoc(), TemplateArgs);
         DRE->setHadMultipleCandidates(MemExpr->getNumDecls() > 1);
         return DRE;
       } else {
         SourceLocation Loc = MemExpr->getMemberLoc();
         if (MemExpr->getQualifier())
           Loc = MemExpr->getQualifierLoc().getBeginLoc();
-        Base =
-            BuildCXXThisExpr(Loc, MemExpr->getBaseType(), /*IsImplicit=*/true);
+        Base = BuildCXXThisExpr(Loc, BaseType, /*IsImplicit=*/true);
       }
     } else
       Base = MemExpr->getBase();
 
     ExprValueKind valueKind;
-    QualType type;
+    QualType Type;
     if (cast<CXXMethodDecl>(Fn)->isStatic()) {
       valueKind = VK_LValue;
-      type = Fn->getType();
+      Type = Deduced ? resugar(BasePointeeType, Fn, Deduced->asArray(),
+                               Fn->getType())
+                     : resugar(BasePointeeType, Fn->getType());
     } else {
       valueKind = VK_PRValue;
-      type = Context.BoundMemberTy;
+      Type = Context.BoundMemberTy;
     }
 
     return BuildMemberExpr(
         Base, MemExpr->isArrow(), MemExpr->getOperatorLoc(),
         MemExpr->getQualifierLoc(), MemExpr->getTemplateKeywordLoc(), Fn, Found,
-        /*HadMultipleCandidates=*/true, MemExpr->getMemberNameInfo(),
-        type, valueKind, OK_Ordinary, TemplateArgs);
+        /*HadMultipleCandidates=*/true, MemExpr->getMemberNameInfo(), Type,
+        valueKind, OK_Ordinary, TemplateArgs, Deduced);
   }
 
   llvm_unreachable("Invalid reference to overloaded function");
 }
 
-ExprResult Sema::FixOverloadedFunctionReference(ExprResult E,
-                                                DeclAccessPair Found,
-                                                FunctionDecl *Fn) {
-  return FixOverloadedFunctionReference(E.get(), Found, Fn);
+ExprResult
+Sema::FixOverloadedFunctionReference(ExprResult E, DeclAccessPair Found,
+                                     FunctionDecl *Fn,
+                                     const TemplateArgumentList *Deduced) {
+  return FixOverloadedFunctionReference(E.get(), Found, Fn, Deduced);
 }
 
 bool clang::shouldEnforceArgLimit(bool PartialOverloading,
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -11,6 +11,7 @@
 #include "TreeTransform.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/ASTLambda.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclFriend.h"
 #include "clang/AST/DeclTemplate.h"
@@ -91,6 +92,1270 @@
   return Depth;
 }
 
+TemplateDecl *getTemplateDecl(NamedDecl *D) {
+  switch (D->getKind()) {
+  case Decl::Kind::Var:
+  case Decl::Kind::ParmVar:
+  case Decl::Kind::Field:
+  case Decl::Kind::IndirectField:
+  case Decl::Kind::EnumConstant:
+  case Decl::Kind::Binding:
+  case Decl::Kind::ImplicitParam:
+  case Decl::Kind::MSGuid:
+  case Decl::Kind::MSProperty:
+  case Decl::Kind::NonTypeTemplateParm:
+  case Decl::Kind::TemplateParamObject:
+    return nullptr;
+  case Decl::Kind::FunctionTemplate:
+  case Decl::Kind::ClassTemplate:
+  case Decl::Kind::TypeAliasTemplate:
+  case Decl::Kind::BuiltinTemplate:
+    return cast<TemplateDecl>(D);
+  case Decl::Kind::VarTemplateSpecialization:
+    return cast<VarTemplateSpecializationDecl>(D)->getSpecializedTemplate();
+  case Decl::Kind::CXXDeductionGuide:
+    return cast<CXXDeductionGuideDecl>(D)->getDeducedTemplate();
+  case Decl::Kind::CXXConversion:
+  case Decl::Kind::CXXConstructor:
+  case Decl::Kind::CXXDestructor:
+  case Decl::Kind::CXXMethod:
+  case Decl::Kind::Function: {
+    const auto *FD = cast<FunctionDecl>(D);
+    switch (FD->getTemplatedKind()) {
+    case FunctionDecl::TK_NonTemplate:
+    case FunctionDecl::TK_DependentNonTemplate:
+      return nullptr;
+    case FunctionDecl::TK_FunctionTemplate:
+      return FD->getDescribedFunctionTemplate();
+    case FunctionDecl::TK_MemberSpecialization:
+      return nullptr;
+    case FunctionDecl::TK_FunctionTemplateSpecialization:
+      return FD->getPrimaryTemplate();
+    case FunctionDecl::TK_DependentFunctionTemplateSpecialization:
+      return nullptr;
+    }
+    llvm_unreachable("Unhandled function template kind");
+  }
+  case Decl::Kind::CXXRecord:
+    return cast<CXXRecordDecl>(D)->getDescribedClassTemplate();
+  case Decl::Kind::TemplateTemplateParm:
+    return cast<TemplateTemplateParmDecl>(D);
+  default:
+    // Maybe fall back to Decl::getDescribedTemplate.
+    D->dumpColor();
+    llvm_unreachable("Unhandled decl kind");
+  }
+}
+
+namespace {
+class Resugarer : public TreeTransform<Resugarer> {
+  using inherited = TreeTransform<Resugarer>;
+
+  struct Inner {
+    const Decl *ReplacedDecl;
+    ArrayRef<TemplateArgument> Args;
+  };
+  Inner CurInner;
+
+  using TemplateToArgs =
+      llvm::DenseMap<const Decl *, ArrayRef<TemplateArgument>>;
+  TemplateToArgs CurTemplateToArgs;
+
+  SmallVector<SmallVector<TemplateArgument, 0>, 4> ArgsBuf;
+
+  const TemplateArgument *getArgument(const Decl *ReplacedDecl, unsigned Index,
+                                      Optional<unsigned> PackIndex) const {
+    ArrayRef<TemplateArgument> Args;
+    if (!CurInner.Args.empty() && CurInner.ReplacedDecl == ReplacedDecl) {
+      Args = CurInner.Args;
+    } else {
+      auto It = CurTemplateToArgs.find(ReplacedDecl);
+      if (It == CurTemplateToArgs.end())
+        return nullptr;
+      Args = It->second;
+    }
+    // FIXME: This should never happen, but some arguments might be missing
+    //        from argument deduction of function templates
+    if (Index >= Args.size())
+      return nullptr;
+    const TemplateArgument &Arg = Args[Index];
+    if (!PackIndex)
+      return &Arg;
+    ArrayRef<TemplateArgument> PackArgs = Arg.getPackAsArray();
+    // FIXME: As above, arguments might be missing.
+    if (*PackIndex >= PackArgs.size())
+      return nullptr;
+    return &PackArgs[PackArgs.size() - 1 - *PackIndex];
+  }
+
+  struct BaseSemanticContextRAII {
+    BaseSemanticContextRAII(Resugarer &R)
+        : R(&R), OldInner(std::move(R.CurInner)) {}
+    ~BaseSemanticContextRAII() { R->CurInner = std::move(OldInner); }
+
+  protected:
+    Resugarer *R;
+
+  private:
+    Inner OldInner;
+  };
+
+public:
+  struct NonTemplateSemanticContextRAII {
+    NonTemplateSemanticContextRAII(Resugarer &R)
+        : R(&R), OldInner(std::move(R.CurInner)) {}
+    ~NonTemplateSemanticContextRAII() { R->CurInner = std::move(OldInner); }
+
+  protected:
+    Resugarer *R;
+
+  private:
+    Inner OldInner;
+  };
+
+  struct SemanticContextRAII : private NonTemplateSemanticContextRAII {
+    SemanticContextRAII(Resugarer &R, NamedDecl *ND,
+                        ArrayRef<TemplateArgument> Args)
+        : NonTemplateSemanticContextRAII(R), OldArgsBufSize(R.ArgsBuf.size()) {
+      assert(ND != nullptr);
+      assert(Args.size() != 0);
+      TemplateDecl *TD = getTemplateDecl(ND);
+      assert(TD != nullptr);
+      R.CurInner = {TD->getCanonicalDecl(), Args};
+    }
+
+    SemanticContextRAII(Resugarer &R, NamedDecl *ND,
+                        ArrayRef<TemplateArgumentLoc> Args)
+        : NonTemplateSemanticContextRAII(R), OldArgsBufSize(R.ArgsBuf.size()) {
+      assert(ND != nullptr);
+      if (Args.size() == 0)
+        return;
+      TemplateDecl *TD = getTemplateDecl(ND);
+      assert(TD != nullptr);
+      R.CurInner.ReplacedDecl = TD->getCanonicalDecl();
+
+      Sema::SFINAETrap Trap(R.SemaRef);
+
+      Qualifiers ThisTypeQuals;
+      CXXRecordDecl *ThisContext = nullptr;
+      if (auto *Method = dyn_cast<CXXMethodDecl>(ND)) {
+        ThisContext = Method->getParent();
+        ThisTypeQuals = Method->getMethodQualifiers();
+      }
+      Sema::CXXThisScopeRAII ThisScope(R.SemaRef, ThisContext, ThisTypeQuals,
+                                       R.SemaRef.getLangOpts().CPlusPlus17);
+
+      TemplateArgumentListInfo TAL;
+      for (const auto &ArgLoc : Args)
+        TAL.addArgument(ArgLoc);
+      SmallVector<TemplateArgument, 0> ConvertedArgs, CanonicalConverted;
+      if (R.SemaRef.CheckTemplateArgumentList(
+              TD, SourceLocation(), TAL, false, ConvertedArgs,
+              CanonicalConverted,
+              /*UpdateArgsWithConversions=*/false)) {
+        // FIXME: This can fail sometimes because we only keep
+        //        the as-written template arguments around for
+        //        functions, and we don't have the information
+        //        to try to deduce them again.
+        assert(TD->getKind() == Decl::Kind::FunctionTemplate);
+        return;
+      }
+      switch (ND->getKind()) {
+      case Decl::Kind::TypeAliasTemplate:
+      case Decl::Kind::BuiltinTemplate:
+      case Decl::Kind::CXXMethod:
+      case Decl::Kind::Function:
+        break;
+      case Decl::Kind::VarTemplateSpecialization: {
+        auto *VD = cast<VarTemplateSpecializationDecl>(ND);
+        auto *VTPSD = VD->getSpecializedTemplateOrPartial()
+                          .dyn_cast<VarTemplatePartialSpecializationDecl *>();
+        if (!VTPSD)
+          break;
+        TemplateParameterList *TPL = VTPSD->getTemplateParameters();
+        TemplateDeductionInfo Info(SourceLocation{}, TPL->getDepth());
+        // FIXME: We can't deal very well with non-canonical template
+        //        arguments so this will fail sometimes.
+        Sema::TemplateDeductionResult Res = R.SemaRef.DeduceTemplateArguments(
+            VTPSD,
+            TemplateArgumentList(TemplateArgumentList::OnStackType{},
+                                 ConvertedArgs),
+            Info);
+        if (Res != Sema::TDK_Success)
+          break;
+        R.CurInner.Args = Info.takeSugared()->asArray();
+        return;
+      }
+      default:
+        ND->dump();
+        llvm_unreachable("Unhandled Template Kind");
+      }
+      R.CurInner.Args = R.ArgsBuf.emplace_back(std::move(ConvertedArgs));
+    }
+
+    ~SemanticContextRAII() { R->ArgsBuf.resize(OldArgsBufSize); }
+
+    size_t OldArgsBufSize;
+  };
+
+  struct NamingContextBase {
+    NamingContextBase(Resugarer &R)
+        : R(&R), OldTemplateToArgs(std::move(R.CurTemplateToArgs)),
+          OldArgsBufSize(R.ArgsBuf.size()) {}
+    ~NamingContextBase() {
+      R->CurTemplateToArgs = std::move(OldTemplateToArgs);
+      R->ArgsBuf.resize(OldArgsBufSize);
+    }
+
+  protected:
+    void insertTemplateToMap(bool Reverse, const Decl *Template,
+                             ArrayRef<TemplateArgument> Args) {
+      Template = Template->getCanonicalDecl();
+      assert(!Args.empty());
+      if (Reverse)
+        R->CurTemplateToArgs.try_emplace(Template, Args);
+      else
+        R->CurTemplateToArgs[Template] = Args;
+    }
+
+    void addTypeToMap(bool Reverse, const Type *T) {
+      struct {
+        NamedDecl *ND;
+        const TemplateSpecializationType *TS;
+      } Entity;
+      {
+        switch (T->getCanonicalTypeInternal()->getTypeClass()) {
+        case Type::Record: {
+          const auto *TS = T->getAsNonAliasTemplateSpecializationType();
+          if (!TS)
+            return;
+          Entity = {TS->getAsRecordDecl(), TS};
+          break;
+        }
+        case Type::InjectedClassName: {
+          const auto *ICN = T->castAs<InjectedClassNameType>();
+          Entity = {ICN->getDecl(), ICN->getInjectedTST()};
+          break;
+        }
+        case Type::TemplateSpecialization:
+        case Type::DependentTemplateSpecialization:
+        case Type::TemplateTypeParm:
+        case Type::Decltype:
+        case Type::DependentName:
+        case Type::Enum:
+        case Type::Builtin:
+        case Type::UnaryTransform:
+          return;
+        default:
+          T->dump();
+          llvm_unreachable("");
+        }
+      }
+      switch (Entity.ND->getKind()) {
+      case Decl::CXXRecord:
+      case Decl::Record:
+        return;
+      case Decl::ClassTemplateSpecialization:
+      case Decl::ClassTemplatePartialSpecialization: {
+        auto *CTSD = cast<ClassTemplateSpecializationDecl>(Entity.ND);
+        if (auto *CTPSD =
+                CTSD->getSpecializedTemplateOrPartial()
+                    .dyn_cast<ClassTemplatePartialSpecializationDecl *>()) {
+          TemplateParameterList *TPL = CTPSD->getTemplateParameters();
+          TemplateDeductionInfo Info(SourceLocation{}, TPL->getDepth());
+          [[maybe_unused]] Sema::TemplateDeductionResult Res =
+              R->SemaRef.DeduceTemplateArguments(
+                  CTPSD,
+                  TemplateArgumentList(TemplateArgumentList::OnStackType{},
+                                       Entity.TS->getConvertedArguments()),
+                  Info);
+          // FIXME: Workaround for CE ASTNodeAPI.json generation failure.
+          // assert(Res == Sema::TDK_Success);
+          if (Res != Sema::TDK_Success)
+            return;
+          return insertTemplateToMap(Reverse, CTSD,
+                                     Info.takeSugared()->asArray());
+        }
+        return insertTemplateToMap(Reverse, CTSD,
+                                   Entity.TS->getConvertedArguments());
+      }
+      default:
+        break;
+      }
+      Entity.ND->dumpColor();
+      llvm_unreachable("Unhandled Decl Kind");
+    }
+
+    Resugarer *R;
+    TemplateToArgs OldTemplateToArgs;
+
+  private:
+    size_t OldArgsBufSize;
+  };
+
+  struct NamingContextRAII : NamingContextBase {
+    NamingContextRAII(Resugarer &R, const NestedNameSpecifier *NNS,
+                      const Type *BaseType = nullptr)
+        : NamingContextBase(R) {
+      if (BaseType) {
+        assert(!BaseType->getAs<ElaboratedType>());
+        addTypeToMap(/*Reverse=*/false, BaseType);
+      }
+      for (/**/; NNS; NNS = NNS->getPrefix()) {
+        switch (NNS->getKind()) {
+        case NestedNameSpecifier::Global:
+        case NestedNameSpecifier::Namespace:
+        case NestedNameSpecifier::NamespaceAlias:
+          return;
+        case NestedNameSpecifier::Identifier:
+        case NestedNameSpecifier::Super:
+          continue;
+        case NestedNameSpecifier::TypeSpec:
+        case NestedNameSpecifier::TypeSpecWithTemplate:
+          addTypeToMap(/*Reverse=*/false, NNS->getAsType());
+          continue;
+        }
+        llvm_unreachable("Unknown NestedNameSpecifier Kind");
+      }
+      for (auto &&I : OldTemplateToArgs) {
+        auto &P = R.CurTemplateToArgs[I.first];
+        if (P.empty())
+          P = I.second;
+      }
+    }
+  };
+
+  struct NamingContextTransformRAII : NamingContextBase {
+    NamingContextTransformRAII(Resugarer &R, NestedNameSpecifierLoc &NNS)
+        : NamingContextBase(R) {
+      SmallVector<NestedNameSpecifierLoc, 4> Qs;
+      bool InheritOldMap = true;
+      for (/**/; NNS; NNS = NNS.getPrefix()) {
+        NestedNameSpecifier::SpecifierKind K =
+            NNS.getNestedNameSpecifier()->getKind();
+        InheritOldMap &= K != NestedNameSpecifier::Global &&
+                         K != NestedNameSpecifier::Namespace &&
+                         K != NestedNameSpecifier::NamespaceAlias;
+        Qs.push_back(NNS);
+      }
+      if (InheritOldMap)
+        R.CurTemplateToArgs.copyFrom(OldTemplateToArgs);
+
+      CXXScopeSpec SS;
+      for (const NestedNameSpecifierLoc &Q : llvm::reverse(Qs)) {
+        const auto *Qnns = Q.getNestedNameSpecifier();
+        switch (Qnns->getKind()) {
+        case NestedNameSpecifier::Global:
+          SS.MakeGlobal(R.SemaRef.Context, Q.getBeginLoc());
+          continue;
+        case NestedNameSpecifier::Namespace:
+          SS.Extend(R.SemaRef.Context, Qnns->getAsNamespace(),
+                    Q.getLocalBeginLoc(), Q.getLocalEndLoc());
+          continue;
+        case NestedNameSpecifier::NamespaceAlias:
+          SS.Extend(R.SemaRef.Context, Qnns->getAsNamespaceAlias(),
+                    Q.getLocalBeginLoc(), Q.getLocalEndLoc());
+          continue;
+        case NestedNameSpecifier::Identifier:
+          SS.Extend(R.SemaRef.Context, Qnns->getAsIdentifier(),
+                    Q.getLocalBeginLoc(), Q.getLocalEndLoc());
+          continue;
+        case NestedNameSpecifier::Super:
+          SS.MakeSuper(R.SemaRef.Context, Qnns->getAsRecordDecl(),
+                       Q.getBeginLoc(), Q.getEndLoc());
+          continue;
+        case NestedNameSpecifier::TypeSpec:
+        case NestedNameSpecifier::TypeSpecWithTemplate: {
+          TypeLocBuilder TLB;
+          TypeLoc TL = Q.getTypeLoc();
+          TLB.reserve(TL.getFullDataSize());
+          QualType T = R.TransformType(TLB, TL);
+          addTypeToMap(/*Reverse=*/true, T.getTypePtr());
+          SS.Extend(R.SemaRef.Context, /*FIXME:*/ SourceLocation(),
+                    TLB.getTypeSourceInfo(R.SemaRef.Context, T)->getTypeLoc(),
+                    Q.getLocalEndLoc());
+          continue;
+        }
+        }
+        llvm_unreachable("Unknown NestedNameSpecifier Kind");
+      }
+      if (SS.getScopeRep() == NNS.getNestedNameSpecifier())
+        return;
+      if (llvm::equal(
+              ArrayRef<char>(SS.location_data(), SS.location_size()),
+              ArrayRef<char>((char *)NNS.getOpaqueData(), NNS.getDataLength())))
+        NNS = NestedNameSpecifierLoc(SS.getScopeRep(), NNS.getOpaqueData());
+      else
+        NNS = SS.getWithLocInContext(R.SemaRef.Context);
+    }
+  };
+
+  Resugarer(Sema &SemaRef) : inherited(SemaRef) {}
+
+  bool AlwaysRebuild() { return false; }
+  bool ReplacingOriginal() { return false; }
+
+  QualType TransformQualifiedType(TypeLocBuilder &TLB, QualifiedTypeLoc TL) {
+    QualType NewUnqual = TransformType(TLB, TL.getUnqualifiedLoc());
+    QualType Result = TL.getType();
+    if (NewUnqual != TL.getUnqualifiedLoc().getType())
+      Result = SemaRef.Context.getQualifiedType(
+          NewUnqual, TL.getType().getLocalQualifiers());
+    TLB.TypeWasModifiedSafely(Result);
+    return Result;
+  }
+
+  QualType TransformAdjustedType(TypeLocBuilder &TLB, AdjustedTypeLoc TL) {
+    const AdjustedType *T = TL.getTypePtr();
+    QualType NewOrig = TransformType(TLB, TL.getOriginalLoc());
+
+    QualType Result = TL.getType();
+    if (NewOrig != T->getOriginalType())
+      Result = SemaRef.Context.getAdjustedType(NewOrig, T->getAdjustedType());
+    TLB.push<AdjustedTypeLoc>(Result);
+    return Result;
+  }
+
+  QualType TransformElaboratedType(TypeLocBuilder &TLB, ElaboratedTypeLoc TL) {
+    NestedNameSpecifierLoc QualifierLoc = TL.getQualifierLoc();
+    NamingContextTransformRAII NamingScope(*this, QualifierLoc);
+    QualType NamedT = TransformType(TLB, TL.getNamedTypeLoc());
+
+    const ElaboratedType *T = TL.getTypePtr();
+    QualType Result = TL.getType();
+    if (QualifierLoc != TL.getQualifierLoc() || NamedT != T->getNamedType())
+      Result = SemaRef.Context.getElaboratedType(
+          T->getKeyword(), QualifierLoc.getNestedNameSpecifier(), NamedT);
+
+    auto NewTL = TLB.push<ElaboratedTypeLoc>(Result);
+    NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
+    NewTL.setQualifierLoc(QualifierLoc);
+    return Result;
+  }
+
+  Decl *TransformDecl(SourceLocation Loc, Decl *D) const { return D; }
+
+  QualType TransformSubstTemplateTypeParmType(TypeLocBuilder &TLB,
+                                              SubstTemplateTypeParmTypeLoc TL) {
+    QualType QT = TL.getType();
+    const SubstTemplateTypeParmType *T = TL.getTypePtr();
+    Decl *ReplacedDecl = T->getReplacedDecl();
+
+    Optional<unsigned> PackIndex = T->getPackIndex();
+    if (const TemplateArgument *Arg =
+            getArgument(ReplacedDecl, T->getIndex(), PackIndex)) {
+      QualType Replacement = Arg->getAsType().getNonPackExpansionType();
+      if (!SemaRef.Context.hasSameType(Replacement, T->getReplacementType())) {
+        Replacement.dump();
+        T->getReplacementType().dump();
+        assert(false);
+      }
+      if (Replacement != T->getReplacementType())
+        QT = SemaRef.Context.getSubstTemplateTypeParmType(
+            Replacement, ReplacedDecl, T->getIndex(), PackIndex);
+    }
+    auto NewTL = TLB.push<SubstTemplateTypeParmTypeLoc>(QT);
+    NewTL.setNameLoc(TL.getNameLoc());
+    return QT;
+  }
+
+  using inherited::TransformTemplateSpecializationType;
+
+  QualType TransformTemplateSpecializationType(TypeLocBuilder &TLB,
+                                               TemplateSpecializationTypeLoc TL,
+                                               TemplateName N) {
+    const TemplateSpecializationType *T = TL.getTypePtr();
+
+    SmallVector<TemplateArgumentLoc, 4> SpecArgs(TL.getNumArgs());
+    for (unsigned I = 0, E = TL.getNumArgs(); I < E; ++I)
+      SpecArgs[I] = TL.getArgLoc(I);
+    TransformTemplateArguments(SpecArgs);
+
+    auto ConvertedArgs = SmallVector<TemplateArgument, 4>(
+        llvm::iterator_range<const TemplateArgument *>(
+            T->getConvertedArguments()));
+    TransformTemplateArguments(ConvertedArgs);
+
+    QualType Underlying = T->desugar();
+    if (T->isTypeAlias()) {
+      SemanticContextRAII SemanticScope(*this, N.getAsTemplateDecl(),
+                                        ConvertedArgs);
+      Underlying = TransformType(Underlying);
+    }
+
+    // FIXME: Rebuild only if changed.
+    QualType Result = SemaRef.Context.getTemplateSpecializationType(
+        N, SpecArgs, ConvertedArgs, /*CanonicalConvertedArgs=*/{}, Underlying);
+
+    auto NewTL = TLB.push<TemplateSpecializationTypeLoc>(Result);
+    NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
+    NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
+    NewTL.setLAngleLoc(TL.getLAngleLoc());
+    NewTL.setRAngleLoc(TL.getRAngleLoc());
+    for (unsigned I = 0, E = SpecArgs.size(); I < E; ++I)
+      NewTL.setArgLocInfo(I, SpecArgs[I].getLocInfo());
+    return Result;
+  }
+
+  QualType TransformDependentTemplateSpecializationType(
+      TypeLocBuilder &TLB, DependentTemplateSpecializationTypeLoc TL) {
+    const DependentTemplateSpecializationType *T = TL.getTypePtr();
+
+    SmallVector<TemplateArgumentLoc, 4> Args(TL.getNumArgs());
+    for (unsigned I = 0, E = TL.getNumArgs(); I < E; ++I)
+      Args[I] = TL.getArgLoc(I);
+
+    NestedNameSpecifierLoc NNS = TL.getQualifierLoc();
+    NamingContextTransformRAII NamingScope(*this, NNS);
+    TransformTemplateArguments(Args);
+    // FIXME: Don't rebuild if nothing changed.
+    QualType Result = SemaRef.Context.getDependentTemplateSpecializationType(
+        T->getKeyword(), NNS.getNestedNameSpecifier(), T->getIdentifier(),
+        Args);
+
+    auto NewTL = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
+    NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
+    NewTL.setQualifierLoc(NNS);
+    NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
+    NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
+    NewTL.setLAngleLoc(TL.getLAngleLoc());
+    NewTL.setRAngleLoc(TL.getRAngleLoc());
+    for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
+      NewTL.setArgLocInfo(I, Args[I].getLocInfo());
+    return Result;
+  }
+
+  TypeSourceInfo *TransformTSIInObjectScope(TypeLoc TL, QualType, NamedDecl *,
+                                            CXXScopeSpec &) = delete;
+
+  QualType TransformDependentTemplateSpecializationType(
+      TypeLocBuilder &, DependentTemplateSpecializationTypeLoc, TemplateName,
+      CXXScopeSpec &) = delete;
+
+  TemplateName TransformTemplateName(CXXScopeSpec &SS, TemplateName Name,
+                                     SourceLocation NameLoc,
+                                     QualType ObjectType = QualType(),
+                                     NamedDecl *FirstQualifierInScope = nullptr,
+                                     bool AllowInjectedClassName = false) {
+    if (Name.getKind() == TemplateName::NameKind::SubstTemplateTemplateParm)
+      return Name; // FIXME: resugar these
+    return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,
+                                            FirstQualifierInScope,
+                                            AllowInjectedClassName);
+  }
+
+  QualType TransformDependentNameType(TypeLocBuilder &TLB,
+                                      DependentNameTypeLoc TL,
+                                      bool DeducedTSTContext = false) {
+    const DependentNameType *T = TL.getTypePtr();
+
+    NestedNameSpecifierLoc QualifierLoc = TL.getQualifierLoc();
+    NamingContextTransformRAII NamingContext(*this, QualifierLoc);
+    assert(QualifierLoc);
+    assert(QualifierLoc.getNestedNameSpecifier()->isDependent());
+    QualType Result = SemaRef.Context.getDependentNameType(
+        T->getKeyword(), QualifierLoc.getNestedNameSpecifier(),
+        T->getIdentifier());
+    auto NewTL = TLB.push<DependentNameTypeLoc>(Result);
+    NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
+    NewTL.setQualifierLoc(QualifierLoc);
+    NewTL.setNameLoc(TL.getNameLoc());
+    return Result;
+  }
+
+  QualType TransformTypedefType(TypeLocBuilder &TLB, TypedefTypeLoc TL) {
+    const TypedefType *T = TL.getTypePtr();
+    const TypedefNameDecl *D = T->getDecl();
+    QualType OldUnderlying = T->desugar();
+    NonTemplateSemanticContextRAII SemanticScope(*this);
+    QualType NewUnderlying = TransformType(OldUnderlying);
+    QualType Result = TL.getType();
+    if (NewUnderlying != OldUnderlying)
+      Result = SemaRef.Context.getTypedefType(D, NewUnderlying);
+    auto NewTL = TLB.push<TypedefTypeLoc>(Result);
+    NewTL.setNameLoc(TL.getNameLoc());
+    return Result;
+  }
+
+  QualType TransformUsingType(TypeLocBuilder &TLB, UsingTypeLoc TL) {
+    const UsingType *T = TL.getTypePtr();
+    const UsingShadowDecl *D = T->getFoundDecl();
+    QualType OldUnderlying = T->desugar();
+    NonTemplateSemanticContextRAII SemanticScope(*this);
+    QualType NewUnderlying = TransformType(OldUnderlying);
+    QualType Result = TL.getType();
+    if (NewUnderlying != OldUnderlying)
+      Result = SemaRef.Context.getUsingType(D, NewUnderlying);
+    TLB.pushTypeSpec(Result).setNameLoc(TL.getNameLoc());
+    return Result;
+  }
+
+  ExprResult TransformExpr(Expr *E) { return E; }
+
+  bool TransformTemplateArgument(const TemplateArgumentLoc &Input,
+                                 TemplateArgumentLoc &Output, bool) = delete;
+
+  bool TransformTemplateArgument(TemplateArgument &Arg) {
+    switch (Arg.getKind()) {
+    case TemplateArgument::Null:
+      llvm_unreachable("Unexpected Null TemplateArgument");
+    case TemplateArgument::Pack: {
+      ArrayRef<TemplateArgument> PackArray = Arg.getPackAsArray();
+      if (PackArray.empty())
+        return false;
+      auto NewPack = PackArray.copy(SemaRef.Context);
+      Arg = TemplateArgument(NewPack);
+      return TransformTemplateArguments(NewPack);
+    }
+    case TemplateArgument::Integral:
+    case TemplateArgument::NullPtr:
+    case TemplateArgument::Declaration: {
+      QualType T = Arg.getNonTypeTemplateArgumentType();
+      QualType NewT = TransformType(T);
+      if (NewT == T)
+        return false;
+      switch (Arg.getKind()) {
+      case TemplateArgument::Integral:
+        Arg = TemplateArgument(SemaRef.Context, Arg.getAsIntegral(), NewT);
+        return true;
+      case TemplateArgument::NullPtr:
+        Arg = TemplateArgument(NewT, /*IsNullPtr=*/true);
+        return true;
+      case TemplateArgument::Declaration:
+        Arg = TemplateArgument(Arg.getAsDecl(), NewT);
+        return true;
+      default:
+        break;
+      }
+      llvm_unreachable("");
+    }
+    case TemplateArgument::Type: {
+      QualType T = TransformType(Arg.getAsType());
+      if (T == Arg.getAsType())
+        return false;
+      Arg = TemplateArgument(T);
+      return true;
+    }
+    case TemplateArgument::Template:
+    case TemplateArgument::TemplateExpansion: {
+      // FIXME: Transform these.
+      return false;
+    }
+    case TemplateArgument::Expression:
+      // FIXME: convert the type of these.
+      return false;
+    }
+    llvm_unreachable("Unexpected TemplateArgument kind");
+  }
+
+  bool TransformTemplateArgument(TemplateArgumentLoc &AL) {
+    const TemplateArgument &Arg = AL.getArgument();
+    switch (Arg.getKind()) {
+    case TemplateArgument::Null:
+      llvm_unreachable("Unexpected Null TemplateArgument");
+    case TemplateArgument::Pack: {
+      ArrayRef<TemplateArgument> PackArray = Arg.getPackAsArray();
+      SmallVector<TemplateArgumentLoc, 4> Pack(PackArray.size());
+      for (unsigned I = 0; I < PackArray.size(); ++I)
+        Pack[I] = SemaRef.getTrivialTemplateArgumentLoc(
+            PackArray[I], QualType(), SourceLocation());
+      bool Changed = TransformTemplateArguments(Pack);
+      SmallVector<TemplateArgument, 4> ROuts(Pack.size());
+      for (unsigned I = 0; I < Pack.size(); ++I)
+        ROuts[I] = Pack[I].getArgument();
+      AL = TemplateArgumentLoc(
+          TemplateArgument::CreatePackCopy(SemaRef.Context, ROuts),
+          AL.getLocInfo());
+      return Changed;
+    }
+    case TemplateArgument::Integral:
+    case TemplateArgument::NullPtr:
+    case TemplateArgument::Declaration: {
+      QualType T = Arg.getNonTypeTemplateArgumentType();
+      QualType NewT = TransformType(T);
+      if (NewT == T)
+        return false;
+      switch (Arg.getKind()) {
+      case TemplateArgument::Integral:
+        AL = TemplateArgumentLoc(
+            TemplateArgument(SemaRef.Context, Arg.getAsIntegral(), NewT),
+            AL.getLocInfo());
+        return true;
+      case TemplateArgument::NullPtr:
+        AL = TemplateArgumentLoc(TemplateArgument(NewT, /*IsNullPtr=*/true),
+                                 AL.getLocInfo());
+        return true;
+      default:
+        AL = TemplateArgumentLoc(TemplateArgument(Arg.getAsDecl(), NewT),
+                                 AL.getLocInfo());
+        return true;
+      }
+      llvm_unreachable("");
+    }
+    case TemplateArgument::Type: {
+      if (Arg.isPackExpansion()) {
+        QualType T = TransformType(Arg.getAsType());
+        if (T == Arg.getAsType())
+          return false;
+        AL = TemplateArgumentLoc(TemplateArgument(T), AL.getLocInfo());
+        return true;
+      }
+      TypeSourceInfo *DI = AL.getTypeSourceInfo();
+      if (!DI)
+        DI = InventTypeSourceInfo(Arg.getAsType());
+      TypeSourceInfo *NewDI = TransformType(DI);
+      if (DI == NewDI)
+        return false;
+      AL = TemplateArgumentLoc(TemplateArgument(NewDI->getType()), NewDI);
+      return true;
+    }
+    case TemplateArgument::Template: {
+      NestedNameSpecifierLoc QualifierLoc = AL.getTemplateQualifierLoc();
+      NamingContextTransformRAII NamingContext(*this, QualifierLoc);
+
+      CXXScopeSpec SS;
+      SS.Adopt(QualifierLoc);
+      TemplateName Template = TransformTemplateName(SS, Arg.getAsTemplate(),
+                                                    AL.getTemplateNameLoc());
+      if (Template.getAsVoidPointer() == Arg.getAsTemplate().getAsVoidPointer())
+        return false;
+
+      AL = TemplateArgumentLoc(SemaRef.Context, TemplateArgument(Template),
+                               QualifierLoc, AL.getTemplateNameLoc());
+      return true;
+    }
+    case TemplateArgument::TemplateExpansion: {
+      AL = TemplateArgumentLoc(
+          TemplateArgument(Arg.getAsTemplateOrTemplatePattern(),
+                           Arg.getNumTemplateExpansions()),
+          AL.getLocInfo());
+      return false;
+    }
+    case TemplateArgument::Expression:
+      // FIXME: convert the type of these.
+      return false;
+    }
+    llvm_unreachable("Unexpected TemplateArgument kind");
+  }
+
+  template <typename InputIterator>
+  bool TransformTemplateArguments(InputIterator First, InputIterator Last,
+                                  TemplateArgumentListInfo &Outputs,
+                                  bool Uneval = true) = delete;
+
+  bool TransformTemplateArguments(MutableArrayRef<TemplateArgumentLoc> Args) {
+    bool Changed = false;
+    for (auto &Arg : Args)
+      Changed |= TransformTemplateArgument(Arg);
+    return Changed;
+  }
+  bool TransformTemplateArguments(MutableArrayRef<TemplateArgument> Args) {
+    bool Changed = false;
+    for (auto &Arg : Args)
+      Changed |= TransformTemplateArgument(Arg);
+    return Changed;
+  }
+
+  QualType TransformPackExpansionType(TypeLocBuilder &TLB,
+                                      PackExpansionTypeLoc TL) {
+    QualType Pattern = TransformType(TLB, TL.getPatternLoc());
+    assert(!Pattern.isNull());
+
+    QualType Result = TL.getType();
+    if (Pattern != TL.getPatternLoc().getType()) {
+      Result = SemaRef.Context.getPackExpansionType(
+          Pattern, TL.getTypePtr()->getNumExpansions(),
+          /*ExpectPackInType=*/false);
+    }
+
+    auto NewT = TLB.push<PackExpansionTypeLoc>(Result);
+    NewT.setEllipsisLoc(TL.getEllipsisLoc());
+    return Result;
+  }
+
+  bool TransformTypes(llvm::ArrayRef<QualType> In,
+                      SmallVectorImpl<QualType> &Out) {
+    bool Changed = false;
+    for (unsigned i = 0; i != In.size(); ++i) {
+      QualType OldType = In[i];
+      QualType NewType = TransformType(OldType);
+      assert(!NewType.isNull());
+      Changed |= NewType != OldType;
+      Out[i] = NewType;
+    }
+    return Changed;
+  }
+
+  QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
+                                      FunctionProtoTypeLoc TL) {
+    const FunctionProtoType *T = TL.getTypePtr();
+
+    QualType ResultType = TransformType(TLB, TL.getReturnLoc());
+    assert(!ResultType.isNull());
+
+    bool Changed = ResultType != TL.getReturnLoc().getType();
+
+    SmallVector<QualType, 4> ParamTypes(T->getNumParams());
+    Changed |= TransformTypes(llvm::ArrayRef<QualType>(T->param_types().begin(),
+                                                       T->param_types().end()),
+                              ParamTypes);
+
+    FunctionProtoType::ExtProtoInfo EPI = T->getExtProtoInfo();
+
+    SmallVector<QualType, 4> ExceptionStorage(
+        EPI.ExceptionSpec.Exceptions.size());
+    Changed |= TransformTypes(EPI.ExceptionSpec.Exceptions, ExceptionStorage);
+    EPI.ExceptionSpec.Exceptions = ExceptionStorage;
+
+    QualType Result =
+        Changed ? SemaRef.Context.getFunctionType(ResultType, ParamTypes, EPI)
+                : TL.getType();
+
+    auto NewTL = TLB.push<FunctionProtoTypeLoc>(Result);
+    NewTL.setLocalRangeBegin(TL.getLocalRangeBegin());
+    NewTL.setLParenLoc(TL.getLParenLoc());
+    NewTL.setRParenLoc(TL.getRParenLoc());
+    NewTL.setExceptionSpecRange(TL.getExceptionSpecRange());
+    NewTL.setLocalRangeEnd(TL.getLocalRangeEnd());
+    for (unsigned i = 0, e = NewTL.getNumParams(); i != e; ++i)
+      NewTL.setParam(i, TL.getParam(i));
+    return Result;
+  }
+
+  bool TransformFunctionTypeParams(ArrayRef<QualType> ParamTypes,
+                                   SmallVectorImpl<QualType> &OutParamTypes) {
+    for (unsigned i = 0; i != ParamTypes.size(); ++i) {
+      QualType NewType = TransformType(ParamTypes[i]);
+      assert(!NewType.isNull());
+      OutParamTypes.push_back(NewType);
+    }
+    return false;
+  }
+
+  QualType TransformAttributedType(TypeLocBuilder &TLB, AttributedTypeLoc TL) {
+    const AttributedType *T = TL.getTypePtr();
+    QualType MT = TransformType(TLB, TL.getModifiedLoc());
+    assert(!MT.isNull());
+
+    const Attr *OldAttr = TL.getAttr();
+    const Attr *NewAttr = OldAttr ? TransformAttr(OldAttr) : nullptr;
+    assert(!OldAttr == !NewAttr);
+
+    // FIXME: Rebuild if Attr changes?
+    QualType Result = TL.getType();
+    if (MT != T->getModifiedType()) {
+      Result = SemaRef.Context.getAttributedType(TL.getAttrKind(), MT,
+                                                 T->getEquivalentType());
+    }
+
+    auto newTL = TLB.push<AttributedTypeLoc>(Result);
+    newTL.setAttr(NewAttr);
+    return Result;
+  }
+
+  QualType TransformAutoType(TypeLocBuilder &TLB, AutoTypeLoc TL) {
+    NestedNameSpecifierLoc NNS;
+    const AutoType *T = TL.getTypePtr();
+
+    SmallVector<TemplateArgumentLoc, 4> Args(TL.getNumArgs());
+    for (unsigned I = 0, E = TL.getNumArgs(); I < E; ++I)
+      Args[I] = TL.getArgLoc(I);
+    bool ChangedArgs = TransformTemplateArguments(Args);
+
+    QualType Deduced = !T->getDeducedType().isNull()
+                           ? TransformType(T->getDeducedType())
+                           : QualType();
+
+    QualType Result = TL.getType();
+    if (Deduced != T->getDeducedType() || ChangedArgs) {
+      NNS = TL.getNestedNameSpecifierLoc();
+      NamingContextTransformRAII NamingContext(*this, NNS);
+      // FIXME: Maybe don't rebuild if all template arguments are the same.
+      llvm::SmallVector<TemplateArgument, 4> TypeConstraintArgs(Args.size());
+      for (unsigned I = 0; I < Args.size(); ++I)
+        TypeConstraintArgs[I] = Args[I].getArgument();
+      Result = SemaRef.Context.getAutoType(
+          Deduced, T->getKeyword(), Deduced.isNull(),
+          T->containsUnexpandedParameterPack(), T->getTypeConstraintConcept(),
+          TypeConstraintArgs);
+    }
+
+    auto NewTL = TLB.push<AutoTypeLoc>(Result);
+    NewTL.setNameLoc(TL.getNameLoc());
+    NewTL.setNestedNameSpecifierLoc(NNS);
+    NewTL.setTemplateKWLoc(TL.getTemplateKWLoc());
+    NewTL.setConceptNameLoc(TL.getConceptNameLoc());
+    NewTL.setFoundDecl(TL.getFoundDecl());
+    NewTL.setLAngleLoc(TL.getLAngleLoc());
+    NewTL.setRAngleLoc(TL.getRAngleLoc());
+    NewTL.setRParenLoc(TL.getRParenLoc());
+    for (unsigned I = 0; I < NewTL.getNumArgs(); ++I)
+      NewTL.setArgLocInfo(I, Args[I].getLocInfo());
+    return Result;
+  }
+
+  QualType TransformConstantArrayType(TypeLocBuilder &TLB,
+                                      ConstantArrayTypeLoc TL) {
+    const ConstantArrayType *T = TL.getTypePtr();
+    QualType ElementType = TransformType(TLB, TL.getElementLoc());
+    assert(!ElementType.isNull());
+
+    // Prefer the expression from the TypeLoc;  the other may have been uniqued.
+    Expr *OldSize = TL.getSizeExpr();
+    if (!OldSize)
+      OldSize = const_cast<Expr *>(T->getSizeExpr());
+    Expr *NewSize = nullptr;
+    if (OldSize) {
+      NewSize = TransformExpr(OldSize).template getAs<Expr>();
+    }
+
+    QualType Result = TL.getType();
+    if (ElementType != T->getElementType() ||
+        (T->getSizeExpr() && NewSize != OldSize)) {
+      Result = SemaRef.Context.getConstantArrayType(
+          ElementType, T->getSize(), NewSize, T->getSizeModifier(),
+          T->getIndexTypeCVRQualifiers());
+    }
+
+    auto NewTL = TLB.push<ArrayTypeLoc>(Result);
+    NewTL.setLBracketLoc(TL.getLBracketLoc());
+    NewTL.setRBracketLoc(TL.getRBracketLoc());
+    NewTL.setSizeExpr(NewSize);
+    return Result;
+  }
+
+  QualType TransformIncompleteArrayType(TypeLocBuilder &TLB,
+                                        IncompleteArrayTypeLoc TL) {
+    const IncompleteArrayType *T = TL.getTypePtr();
+    QualType ElementType = TransformType(TLB, TL.getElementLoc());
+    assert(!ElementType.isNull());
+
+    QualType Result = TL.getType();
+    if (ElementType != T->getElementType()) {
+      Result = SemaRef.Context.getIncompleteArrayType(
+          ElementType, T->getSizeModifier(), T->getIndexTypeCVRQualifiers());
+    }
+
+    auto NewTL = TLB.push<IncompleteArrayTypeLoc>(Result);
+    NewTL.setLBracketLoc(TL.getLBracketLoc());
+    NewTL.setRBracketLoc(TL.getRBracketLoc());
+    NewTL.setSizeExpr(nullptr);
+    return Result;
+  }
+
+  QualType TransformVariableArrayType(TypeLocBuilder &TLB,
+                                      VariableArrayTypeLoc TL) {
+    const VariableArrayType *T = TL.getTypePtr();
+    QualType ElementType = TransformType(TLB, TL.getElementLoc());
+    assert(!ElementType.isNull());
+
+    Expr *NewSize = TransformExpr(T->getSizeExpr()).template getAs<Expr>();
+
+    QualType Result = TL.getType();
+    if (ElementType != T->getElementType() || NewSize != T->getSizeExpr()) {
+      Result = SemaRef.Context.getVariableArrayType(
+          ElementType, NewSize, T->getSizeModifier(),
+          T->getIndexTypeCVRQualifiers(), TL.getBracketsRange());
+    }
+
+    auto NewTL = TLB.push<ArrayTypeLoc>(Result);
+    NewTL.setLBracketLoc(TL.getLBracketLoc());
+    NewTL.setRBracketLoc(TL.getRBracketLoc());
+    NewTL.setSizeExpr(NewSize);
+    return Result;
+  }
+
+  QualType TransformDependentSizedArrayType(TypeLocBuilder &TLB,
+                                            DependentSizedArrayTypeLoc TL) {
+    const DependentSizedArrayType *T = TL.getTypePtr();
+    QualType ElementType = TransformType(TLB, TL.getElementLoc());
+    assert(!ElementType.isNull());
+
+    // Prefer the expression from the TypeLoc;  the other may have been uniqued.
+    Expr *OldSize = TL.getSizeExpr();
+    if (!OldSize)
+      OldSize = const_cast<Expr *>(T->getSizeExpr());
+    Expr *NewSize = nullptr;
+    if (OldSize) {
+      NewSize = TransformExpr(OldSize).template getAs<Expr>();
+    }
+
+    QualType Result = TL.getType();
+    if (ElementType != T->getElementType() || NewSize != OldSize) {
+      Result = SemaRef.Context.getDependentSizedArrayType(
+          ElementType, NewSize, T->getSizeModifier(),
+          T->getIndexTypeCVRQualifiers(), TL.getBracketsRange());
+    }
+
+    auto NewTL = TLB.push<ArrayTypeLoc>(Result);
+    NewTL.setLBracketLoc(TL.getLBracketLoc());
+    NewTL.setRBracketLoc(TL.getRBracketLoc());
+    NewTL.setSizeExpr(NewSize);
+    return Result;
+  }
+
+  QualType TransformBTFTagAttributedType(TypeLocBuilder &TLB,
+                                         BTFTagAttributedTypeLoc TL) {
+    // The BTFTagAttributedType is available for C only.
+    const BTFTagAttributedType *T = TL.getTypePtr();
+
+    QualType NewWrappedType = TransformType(TLB, TL.getWrappedLoc());
+    assert(!NewWrappedType.isNull());
+
+    const Attr *NewAttr = TransformAttr(T->getAttr());
+
+    QualType Result = TL.getType();
+    if (NewWrappedType != T->getWrappedType() || NewAttr != T->getAttr()) {
+      Result =
+          SemaRef.Context.getBTFTagAttributedType(T->getAttr(), NewWrappedType);
+    }
+    TLB.push<BTFTagAttributedTypeLoc>(Result);
+    return Result;
+  }
+
+  QualType TransformDependentAddressSpaceType(TypeLocBuilder &TLB,
+                                              DependentAddressSpaceTypeLoc TL) {
+    const DependentAddressSpaceType *T = TL.getTypePtr();
+
+    QualType pointeeType = TransformType(TLB, TL.getPointeeTypeLoc());
+    assert(!pointeeType.isNull());
+
+    Expr *AddrSpace =
+        TransformExpr(T->getAddrSpaceExpr()).template getAs<Expr>();
+
+    QualType Result = TL.getType();
+    if (pointeeType != T->getPointeeType() ||
+        AddrSpace != T->getAddrSpaceExpr()) {
+      Result = SemaRef.Context.getDependentAddressSpaceType(
+          pointeeType, AddrSpace, T->getAttributeLoc());
+    }
+
+    auto NewTL = TLB.push<DependentAddressSpaceTypeLoc>(Result);
+    NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
+    NewTL.setAttrExprOperand(AddrSpace);
+    NewTL.setAttrNameLoc(TL.getAttrNameLoc());
+    return Result;
+  }
+
+  QualType TransformDeducedTemplateSpecializationType(
+      TypeLocBuilder &TLB, DeducedTemplateSpecializationTypeLoc TL) {
+    const DeducedTemplateSpecializationType *T = TL.getTypePtr();
+
+    CXXScopeSpec SS;
+    TemplateName Template = TransformTemplateName(SS, T->getTemplateName(),
+                                                  TL.getTemplateNameLoc());
+    assert(!Template.isNull());
+
+    QualType NewDeduced;
+    if (!T->getDeducedType().isNull()) {
+      NewDeduced = TransformType(T->getDeducedType());
+      assert(!NewDeduced.isNull());
+    }
+
+    QualType Result = TL.getType();
+    if (Template.getAsVoidPointer() !=
+            T->getTemplateName().getAsVoidPointer() ||
+        NewDeduced != T->getDeducedType())
+      Result = SemaRef.Context.getDeducedTemplateSpecializationType(
+          Template, NewDeduced, T->isDependentType());
+
+    auto NewTL = TLB.push<DeducedTemplateSpecializationTypeLoc>(Result);
+    NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
+    return Result;
+  }
+
+  QualType TransformTypeOfExprType(TypeLocBuilder &TLB, TypeOfExprTypeLoc TL) {
+    ExprResult E = TransformExpr(TL.getUnderlyingExpr());
+    // FIXME: resugar
+    QualType Result = TL.getType();
+    if (E.get() != TL.getUnderlyingExpr()) {
+      Result = SemaRef.BuildTypeofExprType(E.get());
+    }
+    TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result);
+    NewTL.setTypeofLoc(TL.getTypeofLoc());
+    NewTL.setLParenLoc(TL.getLParenLoc());
+    NewTL.setRParenLoc(TL.getRParenLoc());
+    return Result;
+  }
+
+  QualType TransformTypeOfType(TypeLocBuilder &TLB, TypeOfTypeLoc TL) {
+    TypeSourceInfo *Old = TL.getUnderlyingTInfo();
+    TypeSourceInfo *New = TransformType(Old);
+
+    QualType Result = TL.getType();
+    if (New != Old)
+      Result = SemaRef.Context.getTypeOfType(New->getType());
+
+    TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result);
+    NewTL.setTypeofLoc(TL.getTypeofLoc());
+    NewTL.setLParenLoc(TL.getLParenLoc());
+    NewTL.setRParenLoc(TL.getRParenLoc());
+    NewTL.setUnderlyingTInfo(New);
+    return Result;
+  }
+
+  QualType TransformDecltypeType(TypeLocBuilder &TLB, DecltypeTypeLoc TL) {
+    const DecltypeType *T = TL.getTypePtr();
+    QualType NewT = TransformType(T->getUnderlyingType());
+    QualType Result = TL.getType();
+    if (NewT != T->getUnderlyingType())
+      Result = SemaRef.Context.getDecltypeType(T->getUnderlyingExpr(), NewT);
+
+    DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result);
+    NewTL.setDecltypeLoc(TL.getDecltypeLoc());
+    NewTL.setRParenLoc(TL.getRParenLoc());
+    return Result;
+  }
+
+  QualType TransformUnaryTransformType(TypeLocBuilder &TLB,
+                                       UnaryTransformTypeLoc TL) {
+    QualType Result = TL.getType();
+    if (Result->isDependentType()) {
+      TypeSourceInfo *NewBase = TransformType(TL.getUnderlyingTInfo());
+      if (NewBase->getType() != TL.getUnderlyingTInfo()->getType())
+        Result = SemaRef.BuildUnaryTransformType(
+            NewBase->getType(), TL.getTypePtr()->getUTTKind(), TL.getKWLoc());
+    }
+    UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(Result);
+    NewTL.setKWLoc(TL.getKWLoc());
+    NewTL.setParensRange(TL.getParensRange());
+    NewTL.setUnderlyingTInfo(TL.getUnderlyingTInfo());
+    return Result;
+  }
+  // FIXME: missing resugar of enums.
+};
+} // namespace
+
+QualType Sema::resugar(const CXXScopeSpec &SS, QualType T) {
+  if (!getLangOpts().Resugar)
+    return T;
+  Resugarer R(*this);
+  Resugarer::NamingContextRAII NamingScope(R, SS.getScopeRep());
+  return R.TransformType(T);
+}
+
+QualType Sema::resugar(const CXXScopeSpec &SS, NamedDecl *ND,
+                       ArrayRef<TemplateArgumentLoc> Args, QualType T) {
+  assert(ND != nullptr);
+  if (!getLangOpts().Resugar)
+    return T;
+  Resugarer R(*this);
+  Resugarer::NamingContextRAII NamingScope(R, SS.getScopeRep());
+  Resugarer::SemanticContextRAII SemanticScope(R, ND, Args);
+  return R.TransformType(T);
+}
+QualType Sema::resugar(const CXXScopeSpec &SS, NamedDecl *ND,
+                       ArrayRef<TemplateArgument> Args, QualType T) {
+  assert(ND != nullptr);
+  if (!getLangOpts().Resugar)
+    return T;
+  Resugarer R(*this);
+  Resugarer::NamingContextRAII NamingScope(R, SS.getScopeRep());
+  Resugarer::SemanticContextRAII SemanticScope(R, ND, Args);
+  return R.TransformType(T);
+}
+
+static const NestedNameSpecifier *decomposeBaseType(const Type *&Base) {
+  if (const auto *ElTy = Base->getAs<ElaboratedType>()) {
+    Base = ElTy->getNamedType().getTypePtr();
+    return ElTy->getQualifier();
+  }
+  return nullptr;
+}
+
+QualType Sema::resugar(const Type *Base, QualType T) {
+  if (!getLangOpts().Resugar)
+    return T;
+  Resugarer R(*this);
+  const NestedNameSpecifier *BaseNNS = decomposeBaseType(Base);
+  Resugarer::NamingContextRAII BaseScope(R, BaseNNS, Base);
+  return R.TransformType(T);
+}
+
+QualType Sema::resugar(const Type *Base, NamedDecl *ND,
+                       ArrayRef<TemplateArgumentLoc> Args, QualType T) {
+  if (!getLangOpts().Resugar)
+    return T;
+  Resugarer R(*this);
+  const NestedNameSpecifier *BaseNNS = decomposeBaseType(Base);
+  Resugarer::NamingContextRAII BaseScope(R, BaseNNS, Base);
+  Resugarer::SemanticContextRAII SemanticScope(R, ND, Args);
+  return R.TransformType(T);
+}
+QualType Sema::resugar(const Type *Base, NamedDecl *ND,
+                       ArrayRef<TemplateArgument> Args, QualType T) {
+  if (!getLangOpts().Resugar)
+    return T;
+  Resugarer R(*this);
+  const NestedNameSpecifier *BaseNNS = decomposeBaseType(Base);
+  Resugarer::NamingContextRAII BaseScope(R, BaseNNS, Base);
+  Resugarer::SemanticContextRAII SemanticScope(R, ND, Args);
+  return R.TransformType(T);
+}
+
+QualType Sema::resugar(const Type *Base, NestedNameSpecifierLoc &FieldNNS,
+                       QualType T) {
+  if (!getLangOpts().Resugar)
+    return T;
+  Resugarer R(*this);
+  const NestedNameSpecifier *BaseNNS = decomposeBaseType(Base);
+  Resugarer::NamingContextRAII BaseScope(R, BaseNNS, Base);
+  Resugarer::NamingContextTransformRAII FieldScope(R, FieldNNS);
+  return R.TransformType(T);
+}
+
+QualType Sema::resugar(const Type *Base, NestedNameSpecifierLoc &FieldNNS,
+                       NamedDecl *ND, ArrayRef<TemplateArgumentLoc> Args,
+                       QualType T) {
+  if (!getLangOpts().Resugar)
+    return T;
+  Resugarer R(*this);
+  const NestedNameSpecifier *BaseNNS = decomposeBaseType(Base);
+  Resugarer::NamingContextRAII BaseScope(R, BaseNNS, Base);
+  Resugarer::NamingContextTransformRAII FieldScope(R, FieldNNS);
+  Resugarer::SemanticContextRAII SemanticScope(R, ND, Args);
+  return R.TransformType(T);
+}
+QualType Sema::resugar(const Type *Base, NestedNameSpecifierLoc &FieldNNS,
+                       NamedDecl *ND, ArrayRef<TemplateArgument> Args,
+                       QualType T) {
+  if (!getLangOpts().Resugar)
+    return T;
+  Resugarer R(*this);
+  const NestedNameSpecifier *BaseNNS = decomposeBaseType(Base);
+  Resugarer::NamingContextRAII BaseScope(R, BaseNNS, Base);
+  Resugarer::NamingContextTransformRAII FieldScope(R, FieldNNS);
+  Resugarer::SemanticContextRAII SemanticScope(R, ND, Args);
+  return R.TransformType(T);
+}
+
+static QualType getResugaredTemplateSpecializationType(
+    Sema &S, const CXXScopeSpec &SS, TemplateName Template,
+    MutableArrayRef<TemplateArgumentLoc> SpecArgs,
+    MutableArrayRef<TemplateArgument> SugaredConvertedArgs,
+    ArrayRef<TemplateArgument> CanonicalConvertedArgs,
+    QualType Underlying = QualType()) {
+  if (!S.getLangOpts().Resugar)
+    return S.Context.getTemplateSpecializationType(
+        Template, SpecArgs, SugaredConvertedArgs, CanonicalConvertedArgs,
+        Underlying);
+
+  auto *TD = Template.getAsTemplateDecl();
+  bool IsTypeAlias = !Underlying.isNull() && TD && TD->isTypeAlias();
+
+  Resugarer R(S);
+  Resugarer::NamingContextRAII NamingScope(R, SS.getScopeRep());
+  R.TransformTemplateArguments(SpecArgs);
+  R.TransformTemplateArguments(SugaredConvertedArgs);
+  if (IsTypeAlias) {
+    Resugarer::SemanticContextRAII SemanticScope(R, TD, SugaredConvertedArgs);
+    Underlying = R.TransformType(Underlying);
+  }
+  return S.Context.getTemplateSpecializationType(
+      Template, SpecArgs, SugaredConvertedArgs, CanonicalConvertedArgs,
+      Underlying);
+}
+
 /// \brief Determine whether the declaration found is acceptable as the name
 /// of a template and, if so, return that template declaration. Otherwise,
 /// returns null.
@@ -3497,9 +4762,10 @@
 }
 
 static QualType
-checkBuiltinTemplateIdType(Sema &SemaRef, BuiltinTemplateDecl *BTD,
-                           ArrayRef<TemplateArgument> SugaredConverted,
-                           ArrayRef<TemplateArgument> CanonicalConverted,
+checkBuiltinTemplateIdType(Sema &SemaRef, const CXXScopeSpec &SS,
+                           TemplateName Name, BuiltinTemplateDecl *BTD,
+                           MutableArrayRef<TemplateArgument> SugaredConverted,
+                           MutableArrayRef<TemplateArgument> CanonicalConverted,
                            SourceLocation TemplateLoc,
                            TemplateArgumentListInfo &TemplateArgs) {
   ASTContext &Context = SemaRef.getASTContext();
@@ -3565,7 +4831,11 @@
 
     // The first template argument will be reused as the template decl that
     // our synthetic template arguments will be applied to.
-    return SemaRef.CheckTemplateIdType(TN, TemplateLoc, SyntheticTemplateArgs);
+    QualType Result =
+        SemaRef.CheckTemplateIdType(SS, TN, TemplateLoc, SyntheticTemplateArgs);
+    return SemaRef.Context.getTemplateSpecializationType(
+        Name, TemplateArgs.arguments(), SugaredConverted,
+        /*CanonicalConverted=*/{}, Result);
   }
 
   case BTK__type_pack_element:
@@ -3593,8 +4863,12 @@
 
     // We simply return the type at index `Index`.
     int64_t N = Index.getExtValue();
-    return getSubstType(Ts.getPackAsArray()[N].getAsType(), 1,
-                        Ts.pack_size() - 1 - N);
+    // FIXME: resugaring here is actually unnecessary.
+    return getResugaredTemplateSpecializationType(
+        SemaRef, SS, Name, TemplateArgs.arguments(), SugaredConverted,
+        /*CanonicalConverted=*/{},
+        getSubstType(Ts.getPackAsArray()[N].getAsType(), 1,
+                     Ts.pack_size() - 1 - N));
   }
   llvm_unreachable("unexpected BuiltinTemplateDecl!");
 }
@@ -3737,7 +5011,8 @@
   return { FailedCond, Description };
 }
 
-QualType Sema::CheckTemplateIdType(TemplateName Name,
+// FIXME: We should get the context we are in from the TemplateDeclInstantiator.
+QualType Sema::CheckTemplateIdType(const CXXScopeSpec &SS, TemplateName Name,
                                    SourceLocation TemplateLoc,
                                    TemplateArgumentListInfo &TemplateArgs) {
   DependentTemplateName *DTN
@@ -3845,9 +5120,9 @@
       return QualType();
     }
   } else if (auto *BTD = dyn_cast<BuiltinTemplateDecl>(Template)) {
-    CanonType = checkBuiltinTemplateIdType(*this, BTD, SugaredConverted,
-                                           CanonicalConverted, TemplateLoc,
-                                           TemplateArgs);
+    return checkBuiltinTemplateIdType(*this, SS, Name, BTD, SugaredConverted,
+                                      CanonicalConverted, TemplateLoc,
+                                      TemplateArgs);
   } else if (Name.isDependent() ||
              TemplateSpecializationType::anyDependentTemplateArguments(
                  TemplateArgs, CanonicalConverted)) {
@@ -3945,9 +5220,9 @@
   // Build the fully-sugared type for this class template
   // specialization, which refers back to the class template
   // specialization we created or found.
-  return Context.getTemplateSpecializationType(Name, TemplateArgs.arguments(),
-                                               SugaredConverted,
-                                               CanonicalConverted, CanonType);
+  return getResugaredTemplateSpecializationType(
+      *this, SS, Name, TemplateArgs.arguments(), SugaredConverted,
+      CanonicalConverted, CanonType);
 }
 
 void Sema::ActOnUndeclaredTypeTemplateName(Scope *S, TemplateTy &ParsedName,
@@ -4077,7 +5352,8 @@
     return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T));
   }
 
-  QualType SpecTy = CheckTemplateIdType(Template, TemplateIILoc, TemplateArgs);
+  QualType SpecTy =
+      CheckTemplateIdType(SS, Template, TemplateIILoc, TemplateArgs);
   if (SpecTy.isNull())
     return true;
 
@@ -4158,30 +5434,14 @@
     Diag(TAT->getLocation(), diag::note_declared_at);
   }
 
-  QualType Result = CheckTemplateIdType(Template, TemplateLoc, TemplateArgs);
-  if (Result.isNull())
+  QualType T = CheckTemplateIdType(SS, Template, TemplateLoc, TemplateArgs);
+  if (T.isNull())
     return TypeResult(true);
 
-  // Check the tag kind
-  if (const RecordType *RT = Result->getAs<RecordType>()) {
-    RecordDecl *D = RT->getDecl();
-
-    IdentifierInfo *Id = D->getIdentifier();
-    assert(Id && "templated class must have an identifier");
-
-    if (!isAcceptableTagRedeclaration(D, TagKind, TUK == TUK_Definition,
-                                      TagLoc, Id)) {
-      Diag(TagLoc, diag::err_use_with_wrong_tag)
-        << Result
-        << FixItHint::CreateReplacement(SourceRange(TagLoc), D->getKindName());
-      Diag(D->getLocation(), diag::note_previous_use);
-    }
-  }
-
   // Provide source-location information for the template specialization.
   TypeLocBuilder TLB;
-  TemplateSpecializationTypeLoc SpecTL
-    = TLB.push<TemplateSpecializationTypeLoc>(Result);
+  TemplateSpecializationTypeLoc SpecTL =
+      TLB.push<TemplateSpecializationTypeLoc>(T);
   SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
   SpecTL.setTemplateNameLoc(TemplateLoc);
   SpecTL.setLAngleLoc(LAngleLoc);
@@ -4191,11 +5451,29 @@
 
   // Construct an elaborated type containing the nested-name-specifier (if any)
   // and tag keyword.
-  Result = Context.getElaboratedType(Keyword, SS.getScopeRep(), Result);
-  ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(Result);
+  T = Context.getElaboratedType(Keyword, SS.getScopeRep(), T);
+  ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(T);
   ElabTL.setElaboratedKeywordLoc(TagLoc);
   ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
-  return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
+
+  // Check the tag kind
+  if (const RecordType *RT = T->getAs<RecordType>()) {
+    RecordDecl *D = RT->getDecl();
+
+    IdentifierInfo *Id = D->getIdentifier();
+    assert(Id && "templated class must have an identifier");
+
+    if (!isAcceptableTagRedeclaration(D, TagKind, TUK == TUK_Definition, TagLoc,
+                                      Id)) {
+      Diag(TagLoc, diag::err_use_with_wrong_tag)
+          << T
+          << FixItHint::CreateReplacement(SourceRange(TagLoc),
+                                          D->getKindName());
+      Diag(D->getLocation(), diag::note_previous_use);
+    }
+  }
+
+  return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T));
 }
 
 static bool CheckTemplateSpecializationScope(Sema &S, NamedDecl *Specialized,
@@ -7475,7 +8753,8 @@
         if (DiagnoseUseOfDecl(Fn, Arg->getBeginLoc()))
           return ExprError();
 
-        Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
+        // FIXME: resugar
+        Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn, nullptr);
         ArgType = Arg->getType();
       } else
         return ExprError();
@@ -7527,7 +8806,8 @@
         if (DiagnoseUseOfDecl(Fn, Arg->getBeginLoc()))
           return ExprError();
 
-        Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
+        // FIXME: resugar
+        Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn, nullptr);
         ArgType = Arg->getType();
       } else
         return ExprError();
@@ -8604,16 +9884,15 @@
                                        isPartialSpecialization))
     return true;
 
-  // The canonical type
-  QualType CanonType;
+  QualType T;
   if (isPartialSpecialization) {
-    // Build the canonical type that describes the converted template
+    // Build the sugared type that describes the converted template
     // arguments of the class template partial specialization.
-    CanonType = Context.getCanonicalTemplateSpecializationType(
-        Name, CanonicalConverted);
+    T = Context.getTemplateSpecializationType(
+        Name, TemplateArgs.arguments(), SugaredConverted, CanonicalConverted);
 
-    if (Context.hasSameType(CanonType,
-                        ClassTemplate->getInjectedClassNameSpecialization()) &&
+    if (Context.hasSameType(
+            T, ClassTemplate->getInjectedClassNameSpecialization()) &&
         (!Context.getLangOpts().CPlusPlus20 ||
          !TemplateParams->hasAssociatedConstraints())) {
       // C++ [temp.class.spec]p9b3:
@@ -8640,11 +9919,12 @@
     // Create a new class template partial specialization declaration node.
     ClassTemplatePartialSpecializationDecl *PrevPartial
       = cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl);
+    // FIXME: Use SugaredConverted here.
     ClassTemplatePartialSpecializationDecl *Partial =
         ClassTemplatePartialSpecializationDecl::Create(
             Context, Kind, ClassTemplate->getDeclContext(), KWLoc,
             TemplateNameLoc, TemplateParams, ClassTemplate, CanonicalConverted,
-            TemplateArgs, CanonType, PrevPartial);
+            TemplateArgs, T, PrevPartial);
     SetNestedNameSpecifier(*this, Partial, SS);
     if (TemplateParameterLists.size() > 1 && SS.isSet()) {
       Partial->setTemplateParameterListsInfo(
@@ -8677,10 +9957,10 @@
       ClassTemplate->AddSpecialization(Specialization, InsertPos);
 
     if (CurContext->isDependentContext()) {
-      CanonType = Context.getCanonicalTemplateSpecializationType(
-          Name, CanonicalConverted);
+      T = Context.getCanonicalTemplateSpecializationType(Name,
+                                                         CanonicalConverted);
     } else {
-      CanonType = Context.getTypeDeclType(Specialization);
+      T = Context.getTypeDeclType(Specialization);
     }
   }
 
@@ -8713,6 +9993,17 @@
     }
   }
 
+  // Build the fully-sugared type for this class template
+  // specialization as the user wrote in the specialization
+  // itself. This means that we'll pretty-print the type retrieved
+  // from the specialization's declaration the way that the user
+  // actually wrote the specialization, rather than formatting the
+  // name based on the "canonical" representation used to store the
+  // template arguments in the specialization.
+  TypeSourceInfo *WrittenTy = Context.getTemplateSpecializationTypeInfo(
+      Name, TemplateNameLoc, TemplateArgs, SugaredConverted,
+      /*CanonicalConverted=*/{}, T);
+
   // If this is not a friend, note that this is an explicit specialization.
   if (TUK != TUK_Friend)
     Specialization->setSpecializationKind(TSK_ExplicitSpecialization);
@@ -8748,16 +10039,6 @@
       << (isPartialSpecialization? 1 : 0)
       << FixItHint::CreateRemoval(ModulePrivateLoc);
 
-  // Build the fully-sugared type for this class template
-  // specialization as the user wrote in the specialization
-  // itself. This means that we'll pretty-print the type retrieved
-  // from the specialization's declaration the way that the user
-  // actually wrote the specialization, rather than formatting the
-  // name based on the "canonical" representation used to store the
-  // template arguments in the specialization.
-  TypeSourceInfo *WrittenTy = Context.getTemplateSpecializationTypeInfo(
-      Name, TemplateNameLoc, TemplateArgs, SugaredConverted, CanonicalConverted,
-      CanonType);
   if (TUK != TUK_Friend) {
     Specialization->setTypeAsWritten(WrittenTy);
     Specialization->setTemplateKeywordLoc(TemplateKWLoc);
@@ -10647,7 +11928,7 @@
   // Strangely, non-type results are not ignored by this lookup, so the
   // program is ill-formed if it finds an injected-class-name.
   if (TypenameLoc.isValid()) {
-    auto *LookupRD =
+    const auto *LookupRD =
         dyn_cast_or_null<CXXRecordDecl>(computeDeclContext(SS, false));
     if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
       Diag(TemplateIILoc,
@@ -10685,7 +11966,7 @@
     return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
   }
 
-  QualType T = CheckTemplateIdType(Template, TemplateIILoc, TemplateArgs);
+  QualType T = CheckTemplateIdType(SS, Template, TemplateIILoc, TemplateArgs);
   if (T.isNull())
     return true;
 
@@ -10705,8 +11986,7 @@
   TL.setElaboratedKeywordLoc(TypenameLoc);
   TL.setQualifierLoc(SS.getWithLocInContext(Context));
 
-  TypeSourceInfo *TSI = Builder.getTypeSourceInfo(Context, T);
-  return CreateParsedType(T, TSI);
+  return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
 }
 
 
@@ -10912,9 +12192,9 @@
       // We found a type. Build an ElaboratedType, since the
       // typename-specifier was just sugar.
       MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
-      return Context.getElaboratedType(Keyword,
-                                       QualifierLoc.getNestedNameSpecifier(),
-                                       Context.getTypeDeclType(Type));
+      return Context.getElaboratedType(
+          Keyword, QualifierLoc.getNestedNameSpecifier(),
+          resugar(SS, Context.getTypeDeclType(Type)));
     }
 
     // C++ [dcl.type.simple]p2:
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -3699,12 +3699,18 @@
 /// Gets the type of a function for template-argument-deducton
 /// purposes when it's considered as part of an overload set.
 static QualType GetTypeOfFunction(Sema &S, const OverloadExpr::FindResult &R,
-                                  FunctionDecl *Fn) {
+                                  FunctionDecl *Fn,
+                                  const TemplateArgumentListInfo *Args) {
   // We may need to deduce the return type of the function now.
   if (S.getLangOpts().CPlusPlus14 && Fn->getReturnType()->isUndeducedType() &&
       S.DeduceReturnType(Fn, R.Expression->getExprLoc(), /*Diagnose*/ false))
     return {};
 
+  // FIXME: get SS.
+  QualType FT = Fn->getType();
+  if (Args)
+    FT = S.resugar(CXXScopeSpec(), Fn, Args->arguments(), FT);
+
   if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn))
     if (Method->isInstance()) {
       // An instance method that's referenced in a form that doesn't
@@ -3712,12 +3718,14 @@
       if (!R.HasFormOfMemberPointer)
         return {};
 
-      return S.Context.getMemberPointerType(Fn->getType(),
-               S.Context.getTypeDeclType(Method->getParent()).getTypePtr());
+      // FIXME: resugar the class type here.
+      return S.Context.getMemberPointerType(
+          FT, S.Context.getTypeDeclType(Method->getParent()).getTypePtr());
     }
 
-  if (!R.IsAddressOfOperand) return Fn->getType();
-  return S.Context.getPointerType(Fn->getType());
+  if (!R.IsAddressOfOperand)
+    return FT;
+  return S.Context.getPointerType(FT);
 }
 
 /// Apply the deduction rules for overload sets.
@@ -3740,6 +3748,11 @@
   if (R.IsAddressOfOperand)
     TDF |= TDF_IgnoreQualifiers;
 
+  // Gather the explicit template arguments, if any.
+  TemplateArgumentListInfo ExplicitTemplateArgs;
+  if (Ovl->hasExplicitTemplateArgs())
+    Ovl->copyTemplateArgumentsInto(ExplicitTemplateArgs);
+
   // C++0x [temp.deduct.call]p6:
   //   When P is a function type, pointer to function type, or pointer
   //   to member function type:
@@ -3749,23 +3762,20 @@
       !ParamType->isMemberFunctionPointerType()) {
     if (Ovl->hasExplicitTemplateArgs()) {
       // But we can still look for an explicit specialization.
-      if (FunctionDecl *ExplicitSpec
-            = S.ResolveSingleFunctionTemplateSpecialization(Ovl))
-        return GetTypeOfFunction(S, R, ExplicitSpec);
+      if (FunctionDecl *ExplicitSpec =
+              S.ResolveSingleFunctionTemplateSpecialization(
+                  Ovl, ExplicitTemplateArgs))
+        return GetTypeOfFunction(S, R, ExplicitSpec, &ExplicitTemplateArgs);
     }
 
     DeclAccessPair DAP;
     if (FunctionDecl *Viable =
             S.resolveAddressOfSingleOverloadCandidate(Arg, DAP))
-      return GetTypeOfFunction(S, R, Viable);
+      return GetTypeOfFunction(S, R, Viable, nullptr);
 
     return {};
   }
 
-  // Gather the explicit template arguments, if any.
-  TemplateArgumentListInfo ExplicitTemplateArgs;
-  if (Ovl->hasExplicitTemplateArgs())
-    Ovl->copyTemplateArgumentsInto(ExplicitTemplateArgs);
   QualType Match;
   for (UnresolvedSetIterator I = Ovl->decls_begin(),
          E = Ovl->decls_end(); I != E; ++I) {
@@ -3789,7 +3799,7 @@
     }
 
     FunctionDecl *Fn = cast<FunctionDecl>(D);
-    QualType ArgType = GetTypeOfFunction(S, R, Fn);
+    QualType ArgType = GetTypeOfFunction(S, R, Fn, &ExplicitTemplateArgs);
     if (ArgType.isNull()) continue;
 
     // Function-to-pointer conversion.
diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
--- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -6163,7 +6163,8 @@
               Args.addArgument(
                   getTrivialTemplateArgumentLoc(UnpackedArg, QualType(), Loc));
           }
-          QualType T = CheckTemplateIdType(TemplateName(TD), Loc, Args);
+          QualType T =
+              CheckTemplateIdType(CXXScopeSpec(), TemplateName(TD), Loc, Args);
           if (T.isNull())
             return nullptr;
           auto *SubstRecord = T->getAsCXXRecordDecl();
diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
--- a/clang/lib/Sema/SemaType.cpp
+++ b/clang/lib/Sema/SemaType.cpp
@@ -9138,6 +9138,56 @@
   return Context.getTypeOfExprType(E);
 }
 
+static QualType getSameReferencedType(ASTContext &Context, QualType VT,
+                                      QualType ET) {
+  assert(!ET->isReferenceType());
+  if (const auto *VTL = VT->getAs<LValueReferenceType>())
+    ET = Context.getLValueReferenceType(ET, VTL->isSpelledAsLValue());
+  else if (VT->isRValueReferenceType())
+    ET = Context.getRValueReferenceType(ET);
+
+  if (!Context.hasSameUnqualifiedType(ET, VT)) {
+    ET.dump();
+    VT.dump();
+    assert(false && "!hasSameUnqualifiedType");
+  }
+
+  Qualifiers ToAdd = VT.getQualifiers(), ToRemove = ET.getQualifiers();
+  (void)Qualifiers::removeCommonQualifiers(ToAdd, ToRemove);
+
+  SplitQualType Split = ET.split();
+  while (!ToRemove.empty()) {
+    (void)Qualifiers::removeCommonQualifiers(Split.Quals, ToRemove);
+    if (ToRemove.empty())
+      break;
+    QualType Next;
+    switch (ET->getTypeClass()) {
+#define ABSTRACT_TYPE(Class, Parent)
+#define TYPE(Class, Parent)                                                    \
+  case Type::Class: {                                                          \
+    const auto *ty = cast<Class##Type>(ET);                                    \
+    if (!ty->isSugared())                                                      \
+      goto done;                                                               \
+    Next = ty->desugar();                                                      \
+    break;                                                                     \
+  }
+#include "clang/AST/TypeNodes.inc"
+    }
+    Split = Next.split();
+  }
+done:
+  assert(ToRemove.empty());
+  Split.Quals += ToAdd;
+  ET = Context.getQualifiedType(Split);
+
+  if (!Context.hasSameType(ET, VT)) {
+    ET.dump();
+    VT.dump();
+    assert(false && "!hasSameType");
+  }
+  return ET;
+}
+
 /// getDecltypeForExpr - Given an expr, will return the decltype for
 /// that expression, according to the rules in C++11
 /// [dcl.type.simple]p4 and C++11 [expr.lambda.prim]p18.
@@ -9170,18 +9220,20 @@
   // We apply the same rules for Objective-C ivar and property references.
   if (const auto *DRE = dyn_cast<DeclRefExpr>(IDExpr)) {
     const ValueDecl *VD = DRE->getDecl();
-    QualType T = VD->getType();
+    QualType T = getSameReferencedType(Context, VD->getType(), DRE->getType());
     return isa<TemplateParamObjectDecl>(VD) ? T.getUnqualifiedType() : T;
   }
   if (const auto *ME = dyn_cast<MemberExpr>(IDExpr)) {
     if (const auto *VD = ME->getMemberDecl())
       if (isa<FieldDecl>(VD) || isa<VarDecl>(VD))
-        return VD->getType();
+        return getSameReferencedType(Context, VD->getType(), ME->getType());
   } else if (const auto *IR = dyn_cast<ObjCIvarRefExpr>(IDExpr)) {
+    // FIXME: Sugar these. Breaks Modules/odr_hash.mm.
     return IR->getDecl()->getType();
   } else if (const auto *PR = dyn_cast<ObjCPropertyRefExpr>(IDExpr)) {
     if (PR->isExplicitProperty())
-      return PR->getExplicitProperty()->getType();
+      return getSameReferencedType(
+          Context, PR->getExplicitProperty()->getType(), PR->getType());
   } else if (const auto *PE = dyn_cast<PredefinedExpr>(IDExpr)) {
     return PE->getType();
   }
diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h
--- a/clang/lib/Sema/TreeTransform.h
+++ b/clang/lib/Sema/TreeTransform.h
@@ -1009,7 +1009,8 @@
   /// By default, performs semantic analysis when building the template
   /// specialization type. Subclasses may override this routine to provide
   /// different behavior.
-  QualType RebuildTemplateSpecializationType(TemplateName Template,
+  QualType RebuildTemplateSpecializationType(const CXXScopeSpec &SS,
+                                             TemplateName Template,
                                              SourceLocation TemplateLoc,
                                              TemplateArgumentListInfo &Args);
 
@@ -1067,8 +1068,8 @@
 
     // Otherwise, make an elaborated type wrapping a non-dependent
     // specialization.
-    QualType T =
-        getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
+    QualType T = getDerived().RebuildTemplateSpecializationType(SS, InstName,
+                                                                NameLoc, Args);
     if (T.isNull())
       return QualType();
     return SemaRef.Context.getElaboratedType(
@@ -2671,6 +2672,9 @@
                                NamedDecl *FirstQualifierInScope) {
     ExprResult BaseResult = getSema().PerformMemberExprBaseConversion(Base,
                                                                       isArrow);
+    CXXScopeSpec SS;
+    SS.Adopt(QualifierLoc);
+
     if (!Member->getDeclName()) {
       // We have a reference to an unnamed field.  This is always the
       // base of an anonymous struct/union member access, i.e. the
@@ -2686,15 +2690,14 @@
         return ExprError();
       Base = BaseResult.get();
 
-      CXXScopeSpec EmptySS;
+      // FIXME: resugar.
       return getSema().BuildFieldReferenceExpr(
-          Base, isArrow, OpLoc, EmptySS, cast<FieldDecl>(Member),
-          DeclAccessPair::make(FoundDecl, FoundDecl->getAccess()), MemberNameInfo);
+          Base, isArrow, OpLoc, NestedNameSpecifierLoc(),
+          cast<FieldDecl>(Member), Member->getType(),
+          DeclAccessPair::make(FoundDecl, FoundDecl->getAccess()),
+          MemberNameInfo);
     }
 
-    CXXScopeSpec SS;
-    SS.Adopt(QualifierLoc);
-
     Base = BaseResult.get();
     QualType BaseType = Base->getType();
 
@@ -4888,7 +4891,7 @@
     return TL;
 
   TypeSourceInfo *TSI =
-      TransformTSIInObjectScope(TL, ObjectType, UnqualLookup, SS);
+      getDerived().TransformTSIInObjectScope(TL, ObjectType, UnqualLookup, SS);
   if (TSI)
     return TSI->getTypeLoc();
   return TypeLoc();
@@ -4903,8 +4906,8 @@
   if (getDerived().AlreadyTransformed(TSInfo->getType()))
     return TSInfo;
 
-  return TransformTSIInObjectScope(TSInfo->getTypeLoc(), ObjectType,
-                                   UnqualLookup, SS);
+  return getDerived().TransformTSIInObjectScope(TSInfo->getTypeLoc(),
+                                                ObjectType, UnqualLookup, SS);
 }
 
 template <typename Derived>
@@ -5508,7 +5511,8 @@
     TypeLocBuilder &TLB, DependentAddressSpaceTypeLoc TL) {
   const DependentAddressSpaceType *T = TL.getTypePtr();
 
-  QualType pointeeType = getDerived().TransformType(T->getPointeeType());
+  QualType pointeeType =
+      getDerived().TransformType(TLB, TL.getPointeeTypeLoc());
 
   if (pointeeType.isNull())
     return QualType();
@@ -5541,9 +5545,8 @@
     NewTL.setAttrNameLoc(TL.getAttrNameLoc());
 
   } else {
-    TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(
-        Result, getDerived().getBaseLocation());
-    TransformType(TLB, DI->getTypeLoc());
+    // Result is just the pointee type with an extended qualifier added.
+    TLB.TypeWasModifiedSafely(Result);
   }
 
   return Result;
@@ -6701,10 +6704,8 @@
 
   // FIXME: maybe don't rebuild if all the template arguments are the same.
 
-  QualType Result =
-    getDerived().RebuildTemplateSpecializationType(Template,
-                                                   TL.getTemplateNameLoc(),
-                                                   NewTemplateArgs);
+  QualType Result = getDerived().RebuildTemplateSpecializationType(
+      CXXScopeSpec(), Template, TL.getTemplateNameLoc(), NewTemplateArgs);
 
   if (!Result.isNull()) {
     // Specializations of template template parameters are represented as
@@ -6774,10 +6775,8 @@
     return Result;
   }
 
-  QualType Result
-    = getDerived().RebuildTemplateSpecializationType(Template,
-                                                     TL.getTemplateNameLoc(),
-                                                     NewTemplateArgs);
+  QualType Result = getDerived().RebuildTemplateSpecializationType(
+      SS, Template, TL.getTemplateNameLoc(), NewTemplateArgs);
 
   if (!Result.isNull()) {
     /// FIXME: Wrap this in an elaborated-type-specifier?
@@ -11079,8 +11078,7 @@
     getSema().FpPragmaStack.CurrentValue = NewOverrides;
   }
 
-  return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
-                                      Args,
+  return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc, Args,
                                       E->getRParenLoc());
 }
 
@@ -14759,12 +14757,12 @@
   return SemaRef.BuildUnaryTransformType(BaseType, UKind, Loc);
 }
 
-template<typename Derived>
+template <typename Derived>
 QualType TreeTransform<Derived>::RebuildTemplateSpecializationType(
-                                                      TemplateName Template,
-                                             SourceLocation TemplateNameLoc,
-                                     TemplateArgumentListInfo &TemplateArgs) {
-  return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);
+    const CXXScopeSpec &SS, TemplateName Template,
+    SourceLocation TemplateNameLoc, TemplateArgumentListInfo &TemplateArgs) {
+  return SemaRef.CheckTemplateIdType(SS, Template, TemplateNameLoc,
+                                     TemplateArgs);
 }
 
 template<typename Derived>
diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp
--- a/clang/lib/Serialization/ASTReader.cpp
+++ b/clang/lib/Serialization/ASTReader.cpp
@@ -8847,6 +8847,15 @@
     TemplArgs.push_back(readTemplateArgument(Canonicalize));
 }
 
+const TemplateArgumentList *
+ASTRecordReader::readTemplateArgumentList(bool Canonicalize) {
+  SmallVector<TemplateArgument, 8> Args;
+  readTemplateArgumentList(Args, Canonicalize);
+  if (Args.size() == 0)
+    return nullptr;
+  return TemplateArgumentList::CreateCopy(getContext(), Args);
+}
+
 /// Read a UnresolvedSet structure.
 void ASTRecordReader::readUnresolvedSet(LazyASTUnresolvedSet &Set) {
   unsigned NumDecls = readInt();
diff --git a/clang/lib/Serialization/ASTReaderStmt.cpp b/clang/lib/Serialization/ASTReaderStmt.cpp
--- a/clang/lib/Serialization/ASTReaderStmt.cpp
+++ b/clang/lib/Serialization/ASTReaderStmt.cpp
@@ -1027,6 +1027,7 @@
   E->MemberExprBits.HadMultipleCandidates = Record.readInt();
   E->MemberExprBits.NonOdrUseReason = Record.readInt();
   E->MemberExprBits.OperatorLoc = Record.readSourceLocation();
+  E->Deduced = Record.readTemplateArgumentList();
 
   if (HasQualifier || HasFoundDecl) {
     DeclAccessPair FoundDecl;
diff --git a/clang/lib/Serialization/ASTWriterStmt.cpp b/clang/lib/Serialization/ASTWriterStmt.cpp
--- a/clang/lib/Serialization/ASTWriterStmt.cpp
+++ b/clang/lib/Serialization/ASTWriterStmt.cpp
@@ -911,6 +911,10 @@
   Record.push_back(E->hadMultipleCandidates());
   Record.push_back(E->isNonOdrUse());
   Record.AddSourceLocation(E->getOperatorLoc());
+  if (E->Deduced)
+    Record.AddTemplateArgumentList(E->Deduced);
+  else
+    Record.push_back(0);
 
   if (HasFoundDecl) {
     DeclAccessPair FoundDecl = E->getFoundDecl();
diff --git a/clang/lib/StaticAnalyzer/Checkers/PointerSortingChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/PointerSortingChecker.cpp
--- a/clang/lib/StaticAnalyzer/Checkers/PointerSortingChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/PointerSortingChecker.cpp
@@ -79,12 +79,9 @@
                     );
 
   // Match only if the container has pointer-type elements.
-  auto IteratesPointerEltsM = hasArgument(0,
-                                hasType(cxxRecordDecl(has(
-                                  fieldDecl(hasType(hasCanonicalType(
-                                    pointsTo(hasCanonicalType(pointerType()))
-                                  )))
-                              ))));
+  auto IteratesPointerEltsM = hasArgument(
+      0, hasType(hasCanonicalType(hasDeclaration(cxxRecordDecl(has(fieldDecl(
+             hasType(hasCanonicalType(pointsTo(pointerType()))))))))));
 
   auto PointerSortM = traverse(
       TK_AsIs,
diff --git a/clang/test/Analysis/cast-value-notes.cpp b/clang/test/Analysis/cast-value-notes.cpp
--- a/clang/test/Analysis/cast-value-notes.cpp
+++ b/clang/test/Analysis/cast-value-notes.cpp
@@ -73,7 +73,7 @@
 #if defined(X86)
 void evalReferences(const Shape &S) {
   const auto &C = dyn_cast<Circle>(S);
-  // expected-note@-1 {{Assuming 'S' is not a 'const class clang::Circle &'}}
+  // expected-note@-1 {{Assuming 'S' is not a 'const Circle &'}}
   // expected-note@-2 {{Dereference of null pointer}}
   // expected-warning@-3 {{Dereference of null pointer}}
   clang_analyzer_printState();
@@ -86,26 +86,26 @@
   const auto &C = dyn_cast<DEVICE Circle>(S);
   clang_analyzer_printState();
   // X86-CHECK-SUPPRESSED: "dynamic_types": [
-  // X86-CHECK-SUPPRESSED-NEXT: { "region": "SymRegion{reg_$0<const Shape & S>}", "dyn_type": "const __attribute__((address_space(3))) class clang::Circle &", "sub_classable": true }
+  // X86-CHECK-SUPPRESSED-NEXT: { "region": "SymRegion{reg_$0<const Shape & S>}", "dyn_type": "DEVICE Circle const &", "sub_classable": true }
   (void)C;
 }
 #endif
 #if defined(NOT_SUPPRESSED)
 void evalReferences_addrspace(const Shape &S) {
   const auto &C = dyn_cast<DEVICE Circle>(S);
-  // expected-note@-1 {{Assuming 'S' is not a 'const __attribute__((address_space(3))) class clang::Circle &'}}
+  // expected-note@-1 {{Assuming 'S' is not a 'DEVICE Circle const &'}}
   // expected-note@-2 {{Dereference of null pointer}}
   // expected-warning@-3 {{Dereference of null pointer}}
   clang_analyzer_printState();
   // X86-CHECK: "dynamic_types": [
-  // X86-CHECK-NEXT: { "region": "SymRegion{reg_$0<const Shape & S>}", "dyn_type": "const __attribute__((address_space(3))) class clang::Circle &", "sub_classable": true }
+  // X86-CHECK-NEXT: { "region": "SymRegion{reg_$0<const Shape & S>}", "dyn_type": "DEVICE Circle const &", "sub_classable": true }
   (void)C;
 }
 #endif
 #elif defined(MIPS)
 void evalReferences(const Shape &S) {
   const auto &C = dyn_cast<Circle>(S);
-  // expected-note@-1 {{Assuming 'S' is not a 'const class clang::Circle &'}}
+  // expected-note@-1 {{Assuming 'S' is not a 'const Circle &'}}
   // expected-note@-2 {{Dereference of null pointer}}
   // expected-warning@-3 {{Dereference of null pointer}}
 }
@@ -122,25 +122,25 @@
   // expected-note@-1 {{'C' initialized here}}
 
   if (!dyn_cast_or_null<Circle>(C)) {
-    // expected-note@-1 {{Assuming 'C' is a 'const class clang::Circle *'}}
+    // expected-note@-1 {{Assuming 'C' is a 'const Circle *'}}
     // expected-note@-2 {{Taking false branch}}
     return;
   }
 
   if (dyn_cast_or_null<Triangle>(C)) {
-    // expected-note@-1 {{Assuming 'C' is not a 'const class clang::Triangle *'}}
+    // expected-note@-1 {{Assuming 'C' is not a 'const Triangle *'}}
     // expected-note@-2 {{Taking false branch}}
     return;
   }
 
   if (dyn_cast_or_null<Rectangle>(C)) {
-    // expected-note@-1 {{Assuming 'C' is not a 'const class clang::Rectangle *'}}
+    // expected-note@-1 {{Assuming 'C' is not a 'const Rectangle *'}}
     // expected-note@-2 {{Taking false branch}}
     return;
   }
 
   if (dyn_cast_or_null<Hexagon>(C)) {
-    // expected-note@-1 {{Assuming 'C' is not a 'const class clang::Hexagon *'}}
+    // expected-note@-1 {{Assuming 'C' is not a 'const Hexagon *'}}
     // expected-note@-2 {{Taking false branch}}
     return;
   }
@@ -176,29 +176,29 @@
 
 void evalNonNullParamNonNullReturn(const Shape *S) {
   const auto *C = cast<Circle>(S);
-  // expected-note@-1 {{'S' is a 'const class clang::Circle *'}}
+  // expected-note@-1 {{'S' is a 'const Circle *'}}
   // expected-note@-2 {{'C' initialized here}}
 
   if (!dyn_cast_or_null<Circle>(C)) {
-    // expected-note@-1 {{Assuming 'C' is a 'const class clang::Circle *'}}
+    // expected-note@-1 {{Assuming 'C' is a 'const Circle *'}}
     // expected-note@-2 {{Taking false branch}}
     return;
   }
 
   if (dyn_cast_or_null<Triangle>(C)) {
-    // expected-note@-1 {{Assuming 'C' is not a 'const class clang::Triangle *'}}
+    // expected-note@-1 {{Assuming 'C' is not a 'const Triangle *'}}
     // expected-note@-2 {{Taking false branch}}
     return;
   }
 
   if (dyn_cast_or_null<Rectangle>(C)) {
-    // expected-note@-1 {{Assuming 'C' is not a 'const class clang::Rectangle *'}}
+    // expected-note@-1 {{Assuming 'C' is not a 'const Rectangle *'}}
     // expected-note@-2 {{Taking false branch}}
     return;
   }
 
   if (dyn_cast_or_null<Hexagon>(C)) {
-    // expected-note@-1 {{Assuming 'C' is not a 'const class clang::Hexagon *'}}
+    // expected-note@-1 {{Assuming 'C' is not a 'const Hexagon *'}}
     // expected-note@-2 {{Taking false branch}}
     return;
   }
@@ -234,10 +234,10 @@
 
 void evalNonNullParamNullReturn(const Shape *S) {
   const auto *C = dyn_cast_or_null<Circle>(S);
-  // expected-note@-1 {{Assuming 'S' is not a 'const class clang::Circle *'}}
+  // expected-note@-1 {{Assuming 'S' is not a 'const Circle *'}}
 
   if (const auto *T = dyn_cast_or_null<Triangle>(S)) {
-    // expected-note@-1 {{Assuming 'S' is a 'const class clang::Triangle *'}}
+    // expected-note@-1 {{Assuming 'S' is a 'const Triangle *'}}
     // expected-note@-2 {{'T' initialized here}}
     // expected-note@-3 {{'T' is non-null}}
     // expected-note@-4 {{Taking true branch}}
@@ -261,7 +261,7 @@
 
 void evalZeroParamNonNullReturnPointer(const Shape *S) {
   const auto *C = S->castAs<Circle>();
-  // expected-note@-1 {{'S' is a 'const class clang::Circle *'}}
+  // expected-note@-1 {{'S' is a 'const Circle *'}}
   // expected-note@-2 {{'C' initialized here}}
 
   (void)(1 / !C);
@@ -282,12 +282,12 @@
 
 void evalZeroParamNullReturn(const Shape *S) {
   const auto &C = S->getAs<Circle>();
-  // expected-note@-1 {{Assuming 'S' is not a 'const class clang::Circle *'}}
+  // expected-note@-1 {{Assuming 'S' is not a 'const Circle *'}}
   // expected-note@-2 {{Storing null pointer value}}
   // expected-note@-3 {{'C' initialized here}}
 
   if (!dyn_cast_or_null<Triangle>(S)) {
-    // expected-note@-1 {{Assuming 'S' is a 'const class clang::Triangle *'}}
+    // expected-note@-1 {{Assuming 'S' is a 'const Triangle *'}}
     // expected-note@-2 {{Taking false branch}}
     return;
   }
diff --git a/clang/test/Analysis/cast-value-state-dump.cpp b/clang/test/Analysis/cast-value-state-dump.cpp
--- a/clang/test/Analysis/cast-value-state-dump.cpp
+++ b/clang/test/Analysis/cast-value-state-dump.cpp
@@ -18,12 +18,12 @@
 
 void evalNonNullParamNonNullReturn(const Shape *S) {
   const auto *C = dyn_cast_or_null<Circle>(S);
-  // expected-note@-1 {{Assuming 'S' is a 'const class clang::Circle *'}}
+  // expected-note@-1 {{Assuming 'S' is a 'const Circle *'}}
   // expected-note@-2 {{'C' initialized here}}
 
   // FIXME: We assumed that 'S' is a 'Circle' therefore it is not a 'Square'.
   if (dyn_cast_or_null<Square>(S)) {
-    // expected-note@-1 {{Assuming 'S' is not a 'const class clang::Square *'}}
+    // expected-note@-1 {{Assuming 'S' is not a 'const Square *'}}
     // expected-note@-2 {{Taking false branch}}
     return;
   }
@@ -31,7 +31,7 @@
   clang_analyzer_printState();
 
   // CHECK:      "dynamic_types": [
-  // CHECK-NEXT:   { "region": "SymRegion{reg_$0<const Shape * S>}", "dyn_type": "const class clang::Circle", "sub_classable": true }
+  // CHECK-NEXT:   { "region": "SymRegion{reg_$0<const Shape * S>}", "dyn_type": "const Circle", "sub_classable": true }
   // CHECK-NEXT: ],
   // CHECK-NEXT: "dynamic_casts": [
   // CHECK:        { "region": "SymRegion{reg_$0<const Shape * S>}", "casts": [
diff --git a/clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.elab/p3.cpp b/clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.elab/p3.cpp
--- a/clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.elab/p3.cpp
+++ b/clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.elab/p3.cpp
@@ -38,8 +38,8 @@
 
 void b1(struct B<float>);
 void b2(class B<float>);
-void b3(union B<float>); // expected-error {{use of 'B<float>' with tag type that does not match previous declaration}}
-//void b4(enum B<float>); // this just doesn't parse; you can't template an enum directly
+void b3(union B<float>); // expected-error {{use of 'union B<float>' with tag type that does not match previous declaration}}
+// void b4(enum B<float>); // this just doesn't parse; you can't template an enum directly
 
 void c1(struct B<float>::Member);
 void c2(class B<float>::Member);
diff --git a/clang/test/CXX/temp/temp.deduct.guide/p3.cpp b/clang/test/CXX/temp/temp.deduct.guide/p3.cpp
--- a/clang/test/CXX/temp/temp.deduct.guide/p3.cpp
+++ b/clang/test/CXX/temp/temp.deduct.guide/p3.cpp
@@ -33,7 +33,7 @@
 };
 
 A(int) -> int; // expected-error {{deduced type 'int' of deduction guide is not a specialization of template 'A'}}
-template<typename T> A(T) -> B<T>; // expected-error {{deduced type 'B<T>' (aka 'A<type-parameter-0-0>') of deduction guide is not written as a specialization of template 'A'}}
+template <typename T> A(T)->B<T>;         // expected-error {{deduced type 'B<T>' (aka 'A<T>') of deduction guide is not written as a specialization of template 'A'}}
 template<typename T> A(T*) -> const A<T>; // expected-error {{deduced type 'const A<T>' of deduction guide is not a specialization of template 'A'}}
 
 // A deduction-guide shall be declared in the same scope as the corresponding
diff --git a/clang/test/CodeGenCXX/mangle-ms-back-references-pr13207.cpp b/clang/test/CodeGenCXX/mangle-ms-back-references-pr13207.cpp
--- a/clang/test/CodeGenCXX/mangle-ms-back-references-pr13207.cpp
+++ b/clang/test/CodeGenCXX/mangle-ms-back-references-pr13207.cpp
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-win32 | FileCheck %s
+// RUN: %clang_cc1 -fno-resugar -emit-llvm %s -o - -triple=i386-pc-win32 | FileCheck %s
 
 template<class X, class Y, class Z>
 class A {};
@@ -220,6 +220,7 @@
           class T20>
 struct Food {};
 
+// FIXME: Should implement resugaring cache for this.
 using B0 = Food<int, int, int, int, int, int, int, int, int, int,  int, int, int, int, int, int, int, int, int, int>;
 using B1 = Food<B0, B0, B0, B0, B0, B0, B0, B0, B0, B0,  B0, B0, B0, B0, B0, B0, B0, B0, B0, B0>;
 using B2 = Food<B1, B0, B0, B0, B0, B0, B0, B0, B0, B0,  B1, B1, B1, B1, B1, B1, B1, B1, B1, B1>;
diff --git a/clang/test/CodeGenCXX/pr29160.cpp b/clang/test/CodeGenCXX/pr29160.cpp
--- a/clang/test/CodeGenCXX/pr29160.cpp
+++ b/clang/test/CodeGenCXX/pr29160.cpp
@@ -1,8 +1,9 @@
-// RUN: %clang_cc1 -std=c++11 -triple i686-linux-gnu %s -o /dev/null -S -emit-llvm
+// RUN: %clang_cc1 -std=c++11 -fno-resugar -triple i686-linux-gnu %s -o /dev/null -S -emit-llvm
 //
 // This test's failure mode is running ~forever. (For some value of "forever"
 // that's greater than 25 minutes on my machine)
 
+// FIXME: Should implement resugaring cache for this.
 template <typename... Ts>
 struct Foo {
   template <typename... T>
diff --git a/clang/test/Misc/diag-template-diffing.cpp b/clang/test/Misc/diag-template-diffing.cpp
--- a/clang/test/Misc/diag-template-diffing.cpp
+++ b/clang/test/Misc/diag-template-diffing.cpp
@@ -257,24 +257,21 @@
 int k9 = f9(V9<double>());
 
 // CHECK-ELIDE-NOTREE: no matching function for call to 'f9'
-// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'S9<[2 * ...], S9<[2 * ...], double>>' to 'S9<[2 * ...], S9<[2 * ...], const double>>' for 1st argument
+// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'S9<[2 * ...], U9<double>>' to 'S9<[2 * ...], U9<const double>>' for 1st argument
 // CHECK-NOELIDE-NOTREE: no matching function for call to 'f9'
-// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'S9<int, char, S9<int, char, double>>' to 'S9<int, char, S9<int, char, const double>>' for 1st argument
+// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'S9<int, char, U9<double>>' to 'S9<int, char, U9<const double>>' for 1st argument
 // CHECK-ELIDE-TREE: no matching function for call to 'f9'
 // CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
 // CHECK-ELIDE-TREE:   S9<
-// CHECK-ELIDE-TREE:     [2 * ...], 
-// CHECK-ELIDE-TREE:     S9<
-// CHECK-ELIDE-TREE:       [2 * ...], 
+// CHECK-ELIDE-TREE:     [2 * ...],
+// CHECK-ELIDE-TREE:     U9<
 // CHECK-ELIDE-TREE:       [double != const double]>>
 // CHECK-NOELIDE-TREE: no matching function for call to 'f9'
 // CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
 // CHECK-NOELIDE-TREE:   S9<
-// CHECK-NOELIDE-TREE:     int, 
-// CHECK-NOELIDE-TREE:     char, 
-// CHECK-NOELIDE-TREE:     S9<
-// CHECK-NOELIDE-TREE:       int, 
-// CHECK-NOELIDE-TREE:       char, 
+// CHECK-NOELIDE-TREE:     int,
+// CHECK-NOELIDE-TREE:     char,
+// CHECK-NOELIDE-TREE:     U9<
 // CHECK-NOELIDE-TREE:       [double != const double]>>
 
 template<typename ...A> class class_types {};
@@ -1172,7 +1169,7 @@
 // CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<&global, [...]>>' to 'Wrapper<S<&global2, [...]>>'
 
 Wrapper<S<&global, &global>> W13 = MakeWrapper<S<&global, ptr>>();
-// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<[...], nullptr>>' to 'Wrapper<S<[...], &global>>'
+// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<[...], ptr aka nullptr>>' to 'Wrapper<S<[...], &global>>'
 Wrapper<S<&global, ptr>> W14 = MakeWrapper<S<&global, &global>>();
 // CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<[...], &global>>' to 'Wrapper<S<[...], ptr aka nullptr>>'
 }
@@ -1384,8 +1381,8 @@
 template <typename SizeType = int, SizeType = 0> struct A {};
 template <typename R = A<>> R bar();
 A<> &foo() { return bar(); }
-// CHECK-ELIDE-NOTREE: error: non-const lvalue reference to type 'A<...>' cannot bind to a temporary of type 'A<...>'
-// CHECK-NOELIDE-NOTREE: error: non-const lvalue reference to type 'A<int, 0>' cannot bind to a temporary of type 'A<int, 0>'
+// CHECK-ELIDE-NOTREE: error: non-const lvalue reference to type 'A<>' cannot bind to a temporary of type 'A<>'
+// CHECK-NOELIDE-NOTREE: error: non-const lvalue reference to type 'A<>' cannot bind to a temporary of type 'A<>'
 }
 
 namespace PR24587 {
diff --git a/clang/test/Sema/Resugar/resugar-expr.cpp b/clang/test/Sema/Resugar/resugar-expr.cpp
new file mode 100644
--- /dev/null
+++ b/clang/test/Sema/Resugar/resugar-expr.cpp
@@ -0,0 +1,244 @@
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only              -verify=Y %s
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fno-resugar -verify=N %s
+
+enum class Z;
+
+struct bar {};
+
+using Int = int;
+using Float = float;
+using Bar = bar;
+
+namespace t1 {
+template <class A1> struct A {
+  static constexpr A1 a = {};
+};
+
+Z x1 = A<Int>::a;
+// Y-error@-1 {{with an lvalue of type 'const Int' (aka 'const int')}}
+// N-error@-2 {{with an lvalue of type 'const int'}}
+} // namespace t1
+
+namespace t2 {
+template <class A1, class A2> struct A {
+  static constexpr A1 A2::*a = {};
+};
+
+Z x1 = A<Int, Bar>::a;
+// Y-error@-1 {{with an lvalue of type 'Int Bar::*const'}}
+// N-error@-2 {{with an lvalue of type 'int bar::*const'}}
+} // namespace t2
+
+namespace t3 {
+template <class A1> struct A {
+  template <class B1> struct B {
+    static constexpr A1 B1::*a = {};
+  };
+};
+
+Z x1 = A<Float>::B<Bar>::a;
+// Y-error@-1 {{with an lvalue of type 'Float Bar::*const'}}
+// N-error@-2 {{with an lvalue of type 'float bar::*const'}}
+} // namespace t3
+
+namespace t4 {
+template <class A1> A1 (*a)
+();
+
+Z x1 = decltype(a<Int>){}();
+// Y-error@-1 {{with an rvalue of type 'Int' (aka 'int')}}
+// N-error@-2 {{with an rvalue of type 'int'}}
+} // namespace t4
+
+namespace t5 {
+template <class A1> struct A {
+  A1(*a)
+  ();
+};
+
+Z x1 = decltype(A<Int>().a){}();
+// Y-error@-1 {{with an rvalue of type 'Int' (aka 'int')}}
+// N-error@-2 {{with an rvalue of type 'int'}}
+} // namespace t5
+
+namespace t6 {
+template <class A1, class A2> struct A { A2 A1::*f(); };
+
+using M = int;
+using N = int;
+
+struct B {};
+using X = B;
+using Y = B;
+
+auto a = &A<X, M>::f;
+Z x1 = a;
+// Y-error@-1 {{with an lvalue of type 'M X::*(A<X, M>::*)()'}}
+// N-error@-2 {{with an lvalue of type 'int t6::B::*(A<X, M>::*)()'}}
+
+A<Y, N> b;
+Z x2 = (b.*a)();
+// Y-error@-1 {{with an rvalue of type 'M X::*'}}
+// N-error@-2 {{with an rvalue of type 'int t6::B::*'}}
+
+Z x3 = decltype((b.*a)()){};
+// Y-error@-1 {{with an rvalue of type 'decltype((b .* a)())' (aka 'M X::*')}}
+// N-error@-2 {{with an rvalue of type 'decltype((b .* a)())' (aka 'int t6::B::*')}}
+} // namespace t6
+
+namespace t7 {
+template <class A1> struct A { A1 a; };
+auto [a] = A<Int>{};
+
+Z x1 = a;
+// Y-error@-1 {{with an lvalue of type 'Int' (aka 'int')}}
+// N-error@-2 {{with an lvalue of type 'int'}}
+} // namespace t7
+
+namespace t8 {
+template <class A1> struct A {
+  template <class B1> static constexpr B1 (*b)(A1) = nullptr;
+};
+
+Z x1 = A<Float>::b<Int>;
+// Y-error@-1 {{with an lvalue of type 'Int (*const)(Float)' (aka 'int (*const)(float)')}}
+// N-error@-2 {{with an lvalue of type 'int (*const)(float)'}}
+} // namespace t8
+
+namespace t9 {
+template <class A1> struct A {
+  template <class B1> static constexpr auto b = (B1(*)(A1)){};
+};
+
+Z x1 = A<Float>::b<Int>;
+// Y-error@-1 {{with an lvalue of type 'Int (*const)(Float)' (aka 'int (*const)(float)'}}
+// N-error@-2 {{with an lvalue of type 'int (*const)(float)'}}
+} // namespace t9
+
+namespace t10 {
+template <class A1> struct A {
+  template <class B1> static constexpr A1 (*m)(B1) = nullptr;
+};
+
+Z x1 = A<Int>().template m<Float>;
+// Y-error@-1 {{with an lvalue of type 'Int (*const)(Float)' (aka 'int (*const)(float)'}}
+// N-error@-2 {{with an lvalue of type 'int (*const)(float)'}}
+} // namespace t10
+
+namespace t11 {
+template <class A1> A1 a;
+template <class A2> A2 a<A2 *>;
+
+Z x1 = a<Int>;
+// Y-error@-1 {{with an lvalue of type 'Int' (aka 'int')}}
+// N-error@-2 {{with an lvalue of type 'int'}}
+
+Z x2 = a<Float *>;
+// Y-error@-1 {{with an lvalue of type 'Float' (aka 'float'}}
+// N-error@-2 {{with an lvalue of type 'float'}}
+} // namespace t11
+
+namespace t12 {
+template <class A1> struct A { A1 foo(); };
+
+Z x1 = A<Int>().foo();
+// Y-error@-1 {{with an rvalue of type 'Int' (aka 'int')}}
+// N-error@-2 {{with an rvalue of type 'int'}}
+} // namespace t12
+
+namespace t13 {
+template <class A1> struct A {
+  auto foo() { return A1(); };
+};
+
+Z x1 = A<Int>().foo();
+// Y-error@-1 {{with an rvalue of type 'Int' (aka 'int')}}
+// N-error@-2 {{with an rvalue of type 'int'}}
+} // namespace t13
+
+namespace t14 {
+template <class A1> struct A {
+  template <class B1> auto foo1() -> A1 (*)(B1);
+  template <class B1> auto foo2(B1) -> A1 (*)(B1);
+};
+
+Z x1 = A<Int>().foo1<Float>();
+// Y-error@-1 {{with an rvalue of type 'Int (*)(Float)' (aka 'int (*)(float)'}}
+// N-error@-2 {{with an rvalue of type 'int (*)(float)'}}
+
+Z x2 = A<Int>().foo2(Float());
+// Y-error@-1 {{with an rvalue of type 'Int (*)(Float)' (aka 'int (*)(float)'}}
+// N-error@-2 {{with an rvalue of type 'int (*)(float)'}}
+} // namespace t14
+
+namespace t15 {
+template <class A1> struct A {
+  static auto foo() -> A1;
+};
+
+Z x1 = A<Int>().foo();
+// Y-error@-1 {{with an rvalue of type 'Int' (aka 'int')}}
+// N-error@-2 {{with an rvalue of type 'int'}}
+} // namespace t15
+
+namespace t16 {
+template <class A1> static auto foo() -> A1;
+
+Z x1 = foo<Int>();
+// Y-error@-1 {{with an rvalue of type 'Int' (aka 'int')}}
+// N-error@-2 {{with an rvalue of type 'int'}}
+} // namespace t16
+
+namespace t17 {
+template <class A1> static auto foo(A1) -> A1*;
+
+Z x1 = foo(Int());
+// Y-error@-1 {{with an rvalue of type 'Int *' (aka 'int *')}}
+// N-error@-2 {{with an rvalue of type 'int *'}}
+} // namespace t16
+
+namespace t18 {
+template <class A1> struct A {
+  template <class B1> static auto foo() -> A1 (*)(B1);
+};
+
+Z x1 = A<Int>().template foo<Float>();
+// Y-error@-1 {{with an rvalue of type 'Int (*)(Float)' (aka 'int (*)(float)'}}
+// N-error@-2 {{with an rvalue of type 'int (*)(float)'}}
+
+Z x2 = A<Int>::template foo<Float>();
+// Y-error@-1 {{with an rvalue of type 'Int (*)(Float)' (aka 'int (*)(float)'}}
+// N-error@-2 {{with an rvalue of type 'int (*)(float)'}}
+} // namespace t18
+
+namespace t19 {
+template <class A1> struct A {
+  A1 m;
+};
+
+Z x1 = A<Int>().m;
+// Y-error@-1 {{with an rvalue of type 'Int' (aka 'int')}}
+// N-error@-2 {{with an rvalue of type 'int'}}
+} // namespace t19
+
+namespace t20 {
+template <class A1> struct A {
+  static A1 m;
+};
+
+Z x1 = A<Int>().m;
+// Y-error@-1 {{with an lvalue of type 'Int' (aka 'int')}}
+// N-error@-2 {{with an lvalue of type 'int'}}
+} // namespace t20
+
+namespace t21 {
+template <class A1> struct A {
+  struct {
+    A1 m;
+  };
+};
+
+Z x1 = A<Int>().m;
+// Y-error@-1 {{with an rvalue of type 'Int' (aka 'int')}}
+// N-error@-2 {{with an rvalue of type 'int'}}
+} // namespace t21
diff --git a/clang/test/Sema/Resugar/resugar-types.cpp b/clang/test/Sema/Resugar/resugar-types.cpp
new file mode 100644
--- /dev/null
+++ b/clang/test/Sema/Resugar/resugar-types.cpp
@@ -0,0 +1,203 @@
+// RUN: %clang_cc1 -std=c++2b -verify %s
+// expected-no-diagnostics
+
+static constexpr int alignment = 64; // Suitable large alignment.
+
+struct Baz {};
+using Bar [[gnu::aligned(alignment)]] = Baz;
+using Int [[gnu::aligned(alignment)]] = int;
+
+#define TEST(X) static_assert(alignof(X) == alignment)
+#define TEST_NOT(X) static_assert(alignof(X) != alignment)
+
+// Sanity checks.
+TEST_NOT(Baz);
+TEST(Bar);
+
+namespace t1 {
+template <class T> struct foo { using type = T; };
+template <class U> struct foo<U &> { using type = U; };
+
+TEST(typename foo<Bar>::type);
+TEST(typename foo<Bar &>::type);
+} // namespace t1
+
+namespace t2 {
+template <int, class T> struct foo1 { using type = T; };
+template <class T> struct foo2 { using type = typename foo1<1, T>::type; };
+TEST(typename foo2<Bar>::type);
+} // namespace t2
+
+namespace t3 {
+template <class T> struct foo1 {
+  template <int, class U> struct foo2 { using type1 = T; };
+  using type2 = typename foo2<1, int>::type1;
+};
+TEST(typename foo1<Bar>::type2);
+} // namespace t3
+
+namespace t4 {
+template <class T> struct foo {
+  template <class U> using type1 = T;
+  using type2 = type1<int>;
+};
+TEST(typename foo<Bar>::type2);
+} // namespace t4
+
+namespace t5 {
+template <class T> struct foo {
+  template <int, class U> using type1 = U;
+  using type2 = type1<1, T>;
+};
+TEST(typename foo<Bar>::type2);
+} // namespace t5
+
+namespace t6 {
+template <class T> struct foo1 {
+  template <int, class U> struct foo2 { using type = U; };
+  using type2 = typename foo2<1, T>::type;
+};
+TEST(typename foo1<Bar>::type2);
+}; // namespace t6
+
+namespace t7 {
+template <class T> struct foo {
+  template <int, class U> using type1 = U;
+};
+using type2 = typename foo<int>::template type1<1, Bar>;
+TEST(type2);
+} // namespace t7
+
+namespace t8 {
+template <class T> struct foo {
+  using type1 = T;
+};
+template <class T, class> using type2 = T;
+using type3 = typename type2<foo<Bar>, int>::type1;
+TEST(type3);
+} // namespace t8
+
+namespace t9 {
+template <class A, class B> struct Y {
+  using type1 = A;
+  using type2 = B;
+};
+template <class C, class D> using Z = Y<C, D>;
+template <class E> struct foo {
+  template <class F> using apply = Z<F, E>;
+};
+using T1 = foo<Bar>::apply<char>;
+TEST_NOT(T1::type1);
+TEST(T1::type2);
+
+using T2 = foo<int>::apply<Bar>;
+TEST(T2::type1);
+TEST_NOT(T2::type2);
+} // namespace t9
+
+namespace t10 {
+template <class A1, class A2> struct Y {
+  using type1 = A1;
+  using type2 = A2;
+};
+template <typename... Bs> using Z = Y<Bs...>;
+template <typename... Cs> struct foo {
+  template <typename... Ds> using bind = Z<Ds..., Cs...>;
+};
+using T1 = foo<Bar>::bind<char>;
+TEST_NOT(T1::type1);
+TEST(T1::type2);
+
+using T2 = foo<int>::bind<Bar>;
+TEST(T2::type1);
+TEST_NOT(T2::type2);
+} // namespace t10
+
+namespace t11 {
+template <class A1, class A2 = A1> struct A { using type1 = A2; };
+TEST_NOT(A<Bar>::type1); // FIXME
+} // namespace t11
+
+namespace t12 {
+template <class T> struct W {
+  template <class Z, template <class Z1, class Z2 = Z1, class Z3 = T> class TT>
+  struct X {
+    using type1 = TT<Z>;
+  };
+};
+
+template <class Y1, class Y2, class Y3> struct Y {
+  using type2 = Y2;
+  using type3 = Y3;
+};
+
+using T1 = typename W<Bar>::X<Int, Y>::type1;
+TEST_NOT(typename T1::type2); // FIXME
+TEST(typename T1::type3);
+} // namespace t12
+
+namespace t13 {
+template <template <typename...> class C, typename... Us> struct foo {
+  template <typename... Ts> using bind = C<Ts..., Us...>;
+};
+template <typename A1, typename A2> struct Y {
+  using type1 = A1;
+  using type2 = A2;
+};
+template <typename... Ts> using Z = Y<Ts...>;
+
+using T1 = typename foo<Z, Bar>::template bind<int>;
+TEST_NOT(typename T1::type1);
+TEST(typename T1::type2);
+
+using T2 = typename foo<Z, int>::template bind<Bar>;
+TEST(typename T2::type1);
+TEST_NOT(typename T2::type2);
+} // namespace t13
+
+namespace t14 {
+template <int, class A1, class...> struct A { using B = A1; };
+template <class A2, class A3, class... A4> struct A<0, A2, A3, A4...> {
+  using B = typename A<0, A3, A4...>::B;
+};
+using T1 = typename A<0, long, short, Bar>::B;
+TEST(T1);
+} // namespace t14
+
+namespace t15 {
+template <class T, T... Ints> struct foo { using type1 = T; };
+using type2 = typename __make_integer_seq<foo, Int, 1>::type1;
+TEST(type2);
+template <typename T, T N> using type3 = __make_integer_seq<foo, T, N>;
+using type4 = type3<Int, 1>::type1;
+TEST(type4);
+} // namespace t15
+
+namespace t16 {
+template <class A1> struct A {
+  using type1 = A1;
+};
+using type2 = __type_pack_element<0, A<Bar>>::type1;
+TEST(type2);
+} // namespace t16
+
+namespace t17 {
+template <class A1> struct A {
+  using type1 = A1;
+};
+struct C : A<int> {
+  using A::type1;
+};
+TEST(C::A<Bar>::type1);
+TEST_NOT(C::A<int>::type1);
+TEST(C::A<Int>::type1);
+} // namespace t17
+
+namespace t18 {
+template <class A1> struct A;
+template <class B1> struct B {};
+template <class C1> struct A<B<C1>> {
+    using type1 = C1;
+};
+TEST(A<B<Bar>>::type1);
+} // namespace t18
diff --git a/clang/test/SemaCXX/calling-conv-compat.cpp b/clang/test/SemaCXX/calling-conv-compat.cpp
--- a/clang/test/SemaCXX/calling-conv-compat.cpp
+++ b/clang/test/SemaCXX/calling-conv-compat.cpp
@@ -391,9 +391,9 @@
   typedef Fn *p;
 };
 
-void __cdecl f_cdecl();
-Y<decltype(&A::method_thiscall)>::p tmpl9 = &f_cdecl;
-
+// FIXME: Needs converted arguments.
+// void __cdecl f_cdecl();
+// Y<decltype(&A::method_thiscall)>::p tmpl9 = &f_cdecl;
 
 } // end namespace MemberPointers
 
diff --git a/clang/test/SemaTemplate/attributes.cpp b/clang/test/SemaTemplate/attributes.cpp
--- a/clang/test/SemaTemplate/attributes.cpp
+++ b/clang/test/SemaTemplate/attributes.cpp
@@ -616,7 +616,8 @@
   };
   template<typename T> T desugar(T);
   auto it = desugar(MemberTemplate<int>::Iter<const int>());
-  int n = it; // expected-error {{no viable conversion from 'preferred_name::MemberTemplate<int>::const_iterator' to 'int'}}
+  // FIXME: We need to implement a __builtin_canonicalize_type for this ;-)
+  int n = it; // expected-error {{no viable conversion from 'MemberTemplate<int>::Iter<const int>' to 'int'}}
 
   template<int A, int B, typename ...T> struct Foo;
   template<typename ...T> using Bar = Foo<1, 2, T...>;
diff --git a/clang/test/SemaTemplate/deduction-guide.cpp b/clang/test/SemaTemplate/deduction-guide.cpp
--- a/clang/test/SemaTemplate/deduction-guide.cpp
+++ b/clang/test/SemaTemplate/deduction-guide.cpp
@@ -139,7 +139,7 @@
 // CHECK: |-TemplateTypeParmDecl {{.*}} typename depth 0 index 0 ... T
 // CHECK: |-TemplateTypeParmDecl {{.*}} typename depth 0 index 1 U1
 // CHECK: |-TemplateTypeParmDecl {{.*}} typename depth 0 index 2 U2
-// CHECK: `-CXXDeductionGuideDecl {{.*}} 'auto (B<type-parameter-0-1, type-parameter-0-2> *) -> D<T...>'  
+// CHECK: `-CXXDeductionGuideDecl {{.*}} 'auto (B<type-parameter-0-1, type-parameter-0-2> *) -> D<T...>'
 // CHECK:   `-ParmVarDecl {{.*}} 'B<type-parameter-0-1, type-parameter-0-2> *'
 // CHECK: FunctionProtoType {{.*}} 'auto (B<type-parameter-0-1, type-parameter-0-2> *) -> D<T...>' dependent trailing_return
 // CHECK: |-InjectedClassNameType {{.*}} 'D<T...>' dependent
diff --git a/clang/test/SemaTemplate/make_integer_seq.cpp b/clang/test/SemaTemplate/make_integer_seq.cpp
--- a/clang/test/SemaTemplate/make_integer_seq.cpp
+++ b/clang/test/SemaTemplate/make_integer_seq.cpp
@@ -57,7 +57,7 @@
 // CHECK-NEXT:             |     |-TypeAliasTemplate 0x{{[0-9A-Fa-f]+}} 'B'
 // CHECK-NEXT:             |     `-BuiltinType 0x{{[0-9A-Fa-f]+}} 'int'
 // CHECK-NEXT:             |-TemplateArgument expr
-// CHECK-NEXT:             | `-ConstantExpr 0x{{[0-9A-Fa-f]+}} <col:64> 'int'
+// CHECK-NEXT:             | `-ConstantExpr 0x{{[0-9A-Fa-f]+}} <col:64> 'int':'int'
 // CHECK-NEXT:             |   |-value: Int 0
 // CHECK-NEXT:             |   `-IntegerLiteral 0x{{[0-9A-Fa-f]+}} <col:64> 'int':'int' 0
 // CHECK-NEXT:             `-RecordType 0x{{[0-9A-Fa-f]+}} 'A<int, 0>'
@@ -67,58 +67,36 @@
   using test3 = __make_integer_seq<S, T, N>;
 //      CHECK: |-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:67:3, col:43> col:9 test3 '__make_integer_seq<S, T, N>':'__make_integer_seq<S, T, N>'
 // CHECK-NEXT:   `-ElaboratedType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<S, T, N>' sugar dependent
-// CHECK-NEXT:     `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<S, T, N>' sugar dependent alias __make_integer_seq
+// CHECK-NEXT:     `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<S, T, N>' dependent __make_integer_seq
 // CHECK-NEXT:       |-TemplateArgument template S
 // CHECK-NEXT:       |-TemplateArgument type 'T'
 // CHECK-NEXT:       | `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'T' dependent depth 0 index 1
 // CHECK-NEXT:       |   `-TemplateTypeParm 0x{{[0-9A-Fa-f]+}} 'T'
-// CHECK-NEXT:       |-TemplateArgument expr
-// CHECK-NEXT:       | `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:42> 'type-parameter-0-1':'type-parameter-0-1' <Dependent>
-// CHECK-NEXT:       |   `-DeclRefExpr 0x{{[0-9A-Fa-f]+}} <col:42> 'int' NonTypeTemplateParm 0x{{[0-9A-Fa-f]+}} 'N' 'int'
-// CHECK-NEXT:       `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<S, T, N>' dependent __make_integer_seq
-// CHECK-NEXT:         |-TemplateArgument template S
-// CHECK-NEXT:         |-TemplateArgument type 'T'
-// CHECK-NEXT:         | `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'T' dependent depth 0 index 1
-// CHECK-NEXT:         |   `-TemplateTypeParm 0x{{[0-9A-Fa-f]+}} 'T'
-// CHECK-NEXT:         `-TemplateArgument expr
-// CHECK-NEXT:           `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:42> 'type-parameter-0-1':'type-parameter-0-1' <Dependent>
-// CHECK-NEXT:             `-DeclRefExpr 0x{{[0-9A-Fa-f]+}} <col:42> 'int' NonTypeTemplateParm 0x{{[0-9A-Fa-f]+}} 'N' 'int'
+// CHECK-NEXT:       `-TemplateArgument expr
+// CHECK-NEXT:         `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:42> 'type-parameter-0-1':'type-parameter-0-1' <Dependent>
+// CHECK-NEXT:           `-DeclRefExpr 0x{{[0-9A-Fa-f]+}} <col:42> 'int' NonTypeTemplateParm 0x{{[0-9A-Fa-f]+}} 'N' 'int'
 
   using test4 = __make_integer_seq<A, T, 1>;
-//      CHECK: |-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:87:3, col:43> col:9 test4 '__make_integer_seq<A, T, 1>':'__make_integer_seq<A, T, 1>'
+//      CHECK: |-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:79:3, col:43> col:9 test4 '__make_integer_seq<A, T, 1>':'__make_integer_seq<A, T, 1>'
 // CHECK-NEXT:   `-ElaboratedType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<A, T, 1>' sugar dependent
-// CHECK-NEXT:     `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<A, T, 1>' sugar dependent alias __make_integer_seq
+// CHECK-NEXT:     `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<A, T, 1>' dependent __make_integer_seq
 // CHECK-NEXT:       |-TemplateArgument template A
 // CHECK-NEXT:       |-TemplateArgument type 'T'
 // CHECK-NEXT:       | `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'T' dependent depth 0 index 1
 // CHECK-NEXT:       |   `-TemplateTypeParm 0x{{[0-9A-Fa-f]+}} 'T'
-// CHECK-NEXT:       |-TemplateArgument expr
-// CHECK-NEXT:       | `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:42> 'type-parameter-0-1':'type-parameter-0-1' <Dependent>
-// CHECK-NEXT:       |   `-IntegerLiteral 0x{{[0-9A-Fa-f]+}} <col:42> 'int' 1
-// CHECK-NEXT:       `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<A, T, 1>' dependent __make_integer_seq
-// CHECK-NEXT:         |-TemplateArgument template A
-// CHECK-NEXT:         |-TemplateArgument type 'T'
-// CHECK-NEXT:         | `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'T' dependent depth 0 index 1
-// CHECK-NEXT:         |   `-TemplateTypeParm 0x{{[0-9A-Fa-f]+}} 'T'
-// CHECK-NEXT:         `-TemplateArgument expr
-// CHECK-NEXT:           `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:42> 'type-parameter-0-1':'type-parameter-0-1' <Dependent>
-// CHECK-NEXT:             `-IntegerLiteral 0x{{[0-9A-Fa-f]+}} <col:42> 'int' 1
+// CHECK-NEXT:       `-TemplateArgument expr
+// CHECK-NEXT:         `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:42> 'type-parameter-0-1':'type-parameter-0-1' <Dependent>
+// CHECK-NEXT:           `-IntegerLiteral 0x{{[0-9A-Fa-f]+}} <col:42> 'int' 1
 
   using test5 = __make_integer_seq<A, int, N>;
-//      CHECK: `-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:107:3, col:45> col:9 test5 '__make_integer_seq<A, int, N>':'__make_integer_seq<A, int, N>'
+//      CHECK: `-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:91:3, col:45> col:9 test5 '__make_integer_seq<A, int, N>':'__make_integer_seq<A, int, N>'
 // CHECK-NEXT:   `-ElaboratedType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<A, int, N>' sugar dependent
-// CHECK-NEXT:     `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<A, int, N>' sugar dependent alias __make_integer_seq
+// CHECK-NEXT:     `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<A, int, N>' dependent __make_integer_seq
 // CHECK-NEXT:       |-TemplateArgument template A
 // CHECK-NEXT:       |-TemplateArgument type 'int'
 // CHECK-NEXT:       | `-BuiltinType 0x{{[0-9A-Fa-f]+}} 'int'
-// CHECK-NEXT:       |-TemplateArgument expr
-// CHECK-NEXT:       | `-DeclRefExpr 0x{{[0-9A-Fa-f]+}} <col:44> 'int' NonTypeTemplateParm 0x{{[0-9A-Fa-f]+}} 'N' 'int'
-// CHECK-NEXT:       `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<A, int, N>' dependent __make_integer_seq
-// CHECK-NEXT:         |-TemplateArgument template A
-// CHECK-NEXT:         |-TemplateArgument type 'int'
-// CHECK-NEXT:         | `-BuiltinType 0x{{[0-9A-Fa-f]+}} 'int'
-// CHECK-NEXT:         `-TemplateArgument expr
-// CHECK-NEXT:           `-DeclRefExpr 0x{{[0-9A-Fa-f]+}} <col:44> 'int' NonTypeTemplateParm 0x{{[0-9A-Fa-f]+}} 'N' 'int'
+// CHECK-NEXT:       `-TemplateArgument expr
+// CHECK-NEXT:         `-DeclRefExpr 0x{{[0-9A-Fa-f]+}} <col:44> 'int' NonTypeTemplateParm 0x{{[0-9A-Fa-f]+}} 'N' 'int'
 };
 
 // expected-no-diagnostics
diff --git a/clang/test/SemaTemplate/temp_arg_nontype.cpp b/clang/test/SemaTemplate/temp_arg_nontype.cpp
--- a/clang/test/SemaTemplate/temp_arg_nontype.cpp
+++ b/clang/test/SemaTemplate/temp_arg_nontype.cpp
@@ -437,7 +437,7 @@
 
   template<template<typename> class X> struct A {
     template<typename T, X<T> N> struct B; // expected-note 2{{here}}
-    template<typename T> struct B<T, 0> {}; // expected-error {{non-type template argument specializes a template parameter with dependent type 'Y<T>' (aka 'type-parameter-0-0 *')}}
+    template <typename T> struct B<T, 0> {}; // expected-error {{non-type template argument specializes a template parameter with dependent type 'Y<T>' (aka 'T *')}}
   };
   A<X>::B<int, 0> ax;
   A<Y>::B<int, &n> ay; // expected-error {{undefined}} expected-note {{instantiation of}}
diff --git a/clang/test/SemaTemplate/type_pack_element.cpp b/clang/test/SemaTemplate/type_pack_element.cpp
--- a/clang/test/SemaTemplate/type_pack_element.cpp
+++ b/clang/test/SemaTemplate/type_pack_element.cpp
@@ -19,62 +19,38 @@
   using test2 = __type_pack_element<N, Ts...>;
 //      CHECK: |-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:19:3, col:45> col:9 test2 '__type_pack_element<N, Ts...>':'__type_pack_element<N, Ts...>'
 // CHECK-NEXT:   `-ElaboratedType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<N, Ts...>' sugar dependent
-// CHECK-NEXT:     `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<N, Ts...>' sugar dependent alias __type_pack_element
+// CHECK-NEXT:     `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<N, Ts...>' dependent __type_pack_element
 // CHECK-NEXT:       |-TemplateArgument expr
 // CHECK-NEXT:       | `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'unsigned long' <IntegralCast>
 // CHECK-NEXT:       |   `-DeclRefExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'int' NonTypeTemplateParm 0x{{[0-9A-Fa-f]+}} 'N' 'int'
-// CHECK-NEXT:       |-TemplateArgument type 'Ts...'
-// CHECK-NEXT:       | `-PackExpansionType 0x{{[0-9A-Fa-f]+}} 'Ts...' dependent
-// CHECK-NEXT:       |   `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'Ts' dependent contains_unexpanded_pack depth 0 index 1 pack
-// CHECK-NEXT:       |     `-TemplateTypeParm 0x{{[0-9A-Fa-f]+}} 'Ts'
-// CHECK-NEXT:       `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<N, Ts...>' dependent __type_pack_element
-// CHECK-NEXT:         |-TemplateArgument expr
-// CHECK-NEXT:         | `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'unsigned long' <IntegralCast>
-// CHECK-NEXT:         |   `-DeclRefExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'int' NonTypeTemplateParm 0x{{[0-9A-Fa-f]+}} 'N' 'int'
-// CHECK-NEXT:         `-TemplateArgument type 'Ts...'
-// CHECK-NEXT:           `-PackExpansionType 0x{{[0-9A-Fa-f]+}} 'Ts...' dependent
-// CHECK-NEXT:             `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'Ts' dependent contains_unexpanded_pack depth 0 index 1 pack
-// CHECk-NEXT:               `-TemplateTypeParm 0x{{[0-9A-Fa-f]+}} 'Ts'
+// CHECK-NEXT:       `-TemplateArgument type 'Ts...'
+// CHECK-NEXT:         `-PackExpansionType 0x{{[0-9A-Fa-f]+}} 'Ts...' dependent
+// CHECK-NEXT:           `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'Ts' dependent contains_unexpanded_pack depth 0 index 1 pack
+// CHECK-NEXT:             `-TemplateTypeParm 0x{{[0-9A-Fa-f]+}} 'Ts'
 
   using test3 = __type_pack_element<0, Ts...>;
-//      CHECK: |-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:39:3, col:45> col:9 test3 '__type_pack_element<0, Ts...>':'__type_pack_element<0, Ts...>'
+//      CHECK: |-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:31:3, col:45> col:9 test3 '__type_pack_element<0, Ts...>':'__type_pack_element<0, Ts...>'
 // CHECK-NEXT:   `-ElaboratedType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<0, Ts...>' sugar dependent
-// CHECK-NEXT:     `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<0, Ts...>' sugar dependent alias __type_pack_element
+// CHECK-NEXT:     `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<0, Ts...>' dependent __type_pack_element
 // CHECK-NEXT:       |-TemplateArgument expr
 // CHECK-NEXT:       | `-ConstantExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'unsigned long'
 // CHECK-NEXT:       |   |-value: Int 0
 // CHECK-NEXT:       |   `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'unsigned long' <IntegralCast>
 // CHECK-NEXT:       |     `-IntegerLiteral 0x{{[0-9A-Fa-f]+}} <col:37> 'int' 0
-// CHECK-NEXT:       |-TemplateArgument type 'Ts...'
-// CHECK-NEXT:       | `-PackExpansionType 0x{{[0-9A-Fa-f]+}} 'Ts...' dependent
-// CHECK-NEXT:       |   `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'Ts' dependent contains_unexpanded_pack depth 0 index 1 pack
-// CHECK-NEXT:       |     `-TemplateTypeParm 0x{{[0-9A-Fa-f]+}} 'Ts'
-// CHECK-NEXT:       `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<0, Ts...>' dependent __type_pack_element
-// CHECK-NEXT:         |-TemplateArgument expr
-// CHECK-NEXT:         | `-ConstantExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'unsigned long'
-// CHECK-NEXT:         |   |-value: Int 0
-// CHECK-NEXT:         |   `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'unsigned long' <IntegralCast>
-// CHECK-NEXT:         |     `-IntegerLiteral 0x{{[0-9A-Fa-f]+}} <col:37> 'int' 0
-// CHECK-NEXT:         `-TemplateArgument type 'Ts...'
-// CHECK-NEXT:           `-PackExpansionType 0x{{[0-9A-Fa-f]+}} 'Ts...' dependent
-// CHECK-NEXT:             `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'Ts' dependent contains_unexpanded_pack depth 0 index 1 pack
-// CHECK-NEXT:               `-TemplateTypeParm 0x{{[0-9A-Fa-f]+}} 'Ts'
+// CHECK-NEXT:       `-TemplateArgument type 'Ts...'
+// CHECK-NEXT:         `-PackExpansionType 0x{{[0-9A-Fa-f]+}} 'Ts...' dependent
+// CHECK-NEXT:           `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'Ts' dependent contains_unexpanded_pack depth 0 index 1 pack
+// CHECK-NEXT:             `-TemplateTypeParm 0x{{[0-9A-Fa-f]+}} 'Ts'
 
   using test4 = __type_pack_element<N, int>;
-//      CHECK: `-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:63:3, col:43> col:9 test4 '__type_pack_element<N, int>':'__type_pack_element<N, int>'
+//      CHECK: `-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:45:3, col:43> col:9 test4 '__type_pack_element<N, int>':'__type_pack_element<N, int>'
 // CHECK-NEXT:   `-ElaboratedType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<N, int>' sugar dependent
-// CHECK-NEXT:     `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<N, int>' sugar dependent alias __type_pack_element
+// CHECK-NEXT:     `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<N, int>' dependent __type_pack_element
 // CHECK-NEXT:       |-TemplateArgument expr
 // CHECK-NEXT:       | `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'unsigned long' <IntegralCast>
 // CHECK-NEXT:       |   `-DeclRefExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'int' NonTypeTemplateParm 0x{{[0-9A-Fa-f]+}} 'N' 'int'
-// CHECK-NEXT:       |-TemplateArgument type 'int'
-// CHECK-NEXT:       | `-BuiltinType 0x{{[0-9A-Fa-f]+}} 'int'
-// CHECK-NEXT:       `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<N, int>' dependent __type_pack_element
-// CHECK-NEXT:         |-TemplateArgument expr
-// CHECK-NEXT:         | `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'unsigned long' <IntegralCast>
-// CHECK-NEXT:         |   `-DeclRefExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'int' NonTypeTemplateParm 0x{{[0-9A-Fa-f]+}} 'N' 'int'
-// CHECK-NEXT:         `-TemplateArgument type 'int'
-// CHECK-NEXT:           `-BuiltinType 0x{{[0-9A-Fa-f]+}} 'int'
+// CHECK-NEXT:       `-TemplateArgument type 'int'
+// CHECK-NEXT:         `-BuiltinType 0x{{[0-9A-Fa-f]+}} 'int'
 };
 
 // expected-no-diagnostics
diff --git a/clang/unittests/Tooling/StencilTest.cpp b/clang/unittests/Tooling/StencilTest.cpp
--- a/clang/unittests/Tooling/StencilTest.cpp
+++ b/clang/unittests/Tooling/StencilTest.cpp
@@ -555,8 +555,9 @@
 }
 
 TEST_F(StencilTest, DescribeAnonNamespaceType) {
+  // FIXME: We need to implement a __builtin_canonicalize_type for this ;-)
   std::string Snippet = "auto c = desugar<AnonC>(); c;";
-  std::string Expected = "(anonymous namespace)::AnonC";
+  std::string Expected = "AnonC";
   auto StmtMatch =
       matchStmt(Snippet, declRefExpr(hasType(qualType().bind("type"))));
   ASSERT_TRUE(StmtMatch);
diff --git a/libcxx/DELETE.ME b/libcxx/DELETE.ME
--- a/libcxx/DELETE.ME
+++ b/libcxx/DELETE.ME
@@ -1,2 +1,3 @@
 D131858
 D134113
+D127695