[clang] Template Specialization Resugaring - TypeDecl

[mizvekov]

Summary

This is the introductory patch for a larger work which
intends to solve the long standing C++ issue with losing
type sugar when acessing template specializations.

The well known example here is specializing a template
with std::string, but getting diagnostics related to
std::basic_string<char> instead.

This implements a transform which, upon member access,
propagates type sugar from the naming context into the
accessed entity.

It also implements a single use of this transform,
resugaring access to TypeDecls.

For more details and discussion see:
https://discourse.llvm.org/t/rfc-improving-diagnostics-with-template-specialization-resugaring/64294

Signed-off-by: Matheus Izvekov <[e-mail]>

[mizvekov]

.

[mizvekov]

.

[mizvekov]

.

[mizvekov]

.

[mizvekov]

.

[mizvekov]

.

[davrec]

clang/test/Sema/Resugar/resugar-expr.cpp

245

Compositions of MemberExprs/CXXMemberCallExprs have an issue:

template <class A1> struct A {
  struct Inner {
    A1 m;
    A1 f();
  } inner;
  Inner g();
};
Z x1 = A<Int>().inner.m; //No resugar
Z x2 = A<Int>().inner.f(); //No resugar
Z x3 = A<Int>().g().m; //No resugar
Z x4 = A<Int>().g().f(); //No resugar
Z x5 = A<Int>::Inner().m; //ok

Composed CallExprs seem to work but probably warrant a test, e.g.

template <class B1> B1 h(B1);
Z x6 = h(Int());
Z x7 = h(h(Int()));

https://godbolt.org/z/cszrsvh8d

[mizvekov]

clang/test/Sema/Resugar/resugar-expr.cpp

245

Thanks for the feedback!

The problem here I think is that for a MemberExpr, we have to look at not only the BaseType of it for a resugaring context, but instead look at its BaseExpr to see if it or any bases of it, and so on recursively, can provide a resugaring context as well, effectively building one naming context from the whole composition.

I will try to address that later, I probably should work on facilitating the reviews of the other patches in this stack, and then splitting this one big patch up more :)

[Mordante]

libcxx/utils/ci/buildkite-pipeline.yml

377 ↗

(On Diff #456489)

I actually think this change would be nice for libc++ in general. I've has several assertion failures in the bootstrapping CI. Especially with the symbolizer available the crash reports become a lot better.

I'm not convinced the way you used the CXXFLAGS in the CMakeLists.txt is the best way, maybe @ldionne has a better suggestion.

[mizvekov]

libcxx/utils/ci/buildkite-pipeline.yml

377 ↗

(On Diff #456489)

Ah, this is just an idea at this point, this is not even working for crashes in lit-tests, the LIBCXX_TEST_COMPILER_FLAGS setting below did not seem to work.

I would really appreciate suggestions, but meanwhile I'll try to get something minimally working here and spin a separate DR.

[davrec]

clang/lib/Sema/SemaTemplate.cpp

534–540

Haven't thought this through fully, but: would the following make D128113 (storing the pack index in the STTPT or introducing a new sugar type) unnecessary?

map<pair<Decl *, unsigned>, Optional<unsigned>> CurPackIndices;
QualType TransformSubstTemplateTypeParmType(TypeLocBuilder &TLB,
                                              SubstTemplateTypeParmTypeLoc TL) {
   QualType QT = TL.getType();
   const SubstTemplateTypeParmType *T = TL.getTypePtr();
   Decl *ReplacedDecl = T->getReplacedDecl();
   
   Optional<unsigned> &PackIndex = CurPackIndices[{ReplacedDecl, T->getIndex()}];
   if (!PackIndex && T->getReplacedParameter()->isParameterPack())
     PackIndex = 0;
    
   ...

   if (PackIndex)
     ++PackIndex;
     // ^ maybe reset to zero if > pack size, if we might be resugaring multiple expansions
   return QT;
}

[davrec]

clang/lib/Sema/SemaTemplate.cpp

534–540

Disregard above - upon further thought this does not improve the things; there still isn't enough info about the substitutions. I.e. the issue is with substitutions, not the parameter declarations for which they are substituted. So a sugar node wrapping the STTPTs to represent each expansion instance really is needed. Then when we have that I think we could map from those to their current pack indices per the above to infer the pack indices.

For this sugar node, maybe we could just modify SubstTemplateTypeParmPackType so it is not just canonical, but can also be sugar wrapping substituted STTPTs, as opposed to introducing a new Subst* type class?

[mizvekov]

clang/lib/Sema/SemaTemplate.cpp

534–540

I will reply to this on https://reviews.llvm.org/D128113.

[davrec]

First thank you for having separated out the public AST changes into other patches, it makes these mostly-Sema changes much easier to review.

I don't see any major issues with the code, though this would benefit from a close look from more folks with deeper Sema familiarity. Maybe @rjmccall would be willing or could @ someone?

The larger issues:

1. Performance - can we see some numbers? and
2. There are a lot of FIXMEs introduced - understandable because of the scale, but it would be nice to hear you commit to eventually getting to those because otherwise they will probably remain indefinitely. @aaron.ballman should probably weigh in/sign off on this one given the number of FIXMEs, which probably can't be handled before @mizvekov 's deadline (when is that again?).

clang/lib/Sema/SemaCXXScopeSpec.cpp

879–882

Move back down?

993–999

Move back up?

clang/lib/Sema/SemaExpr.cpp

3427–3430

Does this need the same changes as Sema::FixOverloadedFunctionReference? (see below)

20800

Could this be done same as earlier (lines 19548-19553)?

clang/lib/Sema/SemaExprMember.cpp

1862

Rename to FieldQuals

clang/lib/Sema/SemaOverload.cpp

15357

I think this should have said "Duplicated from diagnoseUncapturableValueReferenceOrBinding" - if so do we need the below changes over there too?

clang/lib/Sema/SemaTemplate.cpp

95

static/move to namespace {} below. Or make it a public method of Decl? Decl::getOriginalDescribedTemplate() or something like that? (If you go that route then best to fall back to getDescribedTemplate instead of the unreachable.)

130

Not sure of policy, should this dump should be removed? Several others below too.

161

Wouldn't hurt to add a brief comment above each RAII class describing its role

257

Would be nice to have a comment explaining the effect of Reverse here or above addTypeToMap. (Reverse iteration?)

265

Could clarify to CXXRecordDecl

293

Add message

466

Maybe include T->OwnedTagDecl arg for consistency with deduction resugaring

479

AssociatedDecl

743

Add message

4783

Change back to original?

5371–5386

Move back up?

clang/lib/Sema/TreeTransform.h

2679–2681

Move back down?

clang/test/Sema/Resugar/resugar-expr.cpp

245

Inheritance is also an issue:

https://godbolt.org/z/81nPqzsrd

using Int = int;
enum class Z;

template<typename A1>
struct A {
    A1 m;
};

template<typename A1>
struct B : A<A1> {};

Z x2 = B<Int>().m; //doesn't resugar

[mizvekov]

In D127695#3829020, @davrec wrote:

The larger issues:

1. Performance - can we see some numbers? and

There are still work left to do on a couple of enablers, and some other changes, in order to get performance on a level which is meaningful to discuss.
The next bit of work here is to get rid of deducing partial specializations during resugaring, which hits some test cases specially bad.

1. There are a lot of FIXMEs introduced - understandable because of the scale, but it would be nice to hear you commit to eventually getting to those because otherwise they will probably remain indefinitely.

From the MR desciption, I am sorry that it's not clear that this is not finished and not really ready for review at that level of detail.

So I am leaving some dumps and other stuff meanwhile, but will clean this up when it's almost there. And I will add the much needed patch description.

The tool that I am using to handle phabricator (moz-phab) is really finicky about leaving the "Changes planned" status, so this was lost here.
I addressed most of your comments though.
For the other comments, some other work has to be finished first in order to address them.

@aaron.ballman should probably weigh in/sign off on this one given the number of FIXMEs, which probably can't be handled before @mizvekov 's deadline (when is that again?).

I am not counting anymore that I will have everything merged by the beginning of November. Don't worry too much about deadlines, we have done a lot as part of the GSoC already, much thanks to you for helping push the reviews :)
The work will continue afterwards in any case.

clang/lib/Sema/SemaTemplate.cpp

95

This function will disappear soon, after a few other changes.

[rjmccall]

What is this work about?

[mizvekov]

In D127695#3860237, @rjmccall wrote:

What is this work about?

I have written more about it in this discourse thread: https://discourse.llvm.org/t/rfc-improving-diagnostics-with-template-specialization-resugaring/64294

[rjmccall]

I see, thank you. I know you've marked this a WIP, but it's always good to describe these things in the patch description; that's what it's for.

This is quite exciting! Thank you for looking into this.

I think you could usefully be much more incremental here. Obviously the resugaring transform is one big piece, but it's likely that you could usefully roll out the applications of it one at a time and see some incremental improvements, and it would be a lot easier for us to then review the changes you're needing to make to see why you're making them. That shouldn't make it any more difficult to measure holistic things like the overall compile-time impact of resugaring — it's all filtering through a single place, so you ought to be able to easily disable it there. You could also disable it by default by leaving it behind a -cc1 flag that you only enable in your tests. That would let you actually land the work incrementally, which I would have no objection to.

[mizvekov]

In D127695#3860316, @rjmccall wrote:

I see, thank you. I know you've marked this a WIP, but it's always good to describe these things in the patch description; that's what it's for.

Done! I have also removed the WIP. While there is still ongoing work with precursors of this patch and it might reflect in some changes here, I don't think anything significant will change, and this is good for review now.

This is quite exciting! Thank you for looking into this.

Thanks!

I think you could usefully be much more incremental here. Obviously the resugaring transform is one big piece, but it's likely that you could usefully roll out the applications of it one at a time and see some incremental improvements, and it would be a lot easier for us to then review the changes you're needing to make to see why you're making them. That shouldn't make it any more difficult to measure holistic things like the overall compile-time impact of resugaring — it's all filtering through a single place, so you ought to be able to easily disable it there. You could also disable it by default by leaving it behind a -cc1 flag that you only enable in your tests. That would let you actually land the work incrementally, which I would have no objection to.

Done.

I have split the resugaring applications in three parts for now.

I consider this patch and the next one to be a single application of the transform, each.

re your concerns and earlier question from @davrec regarding performance, right now we are regressing a couple of test cases in llvm-compile-time-tracker by about 1%:

 		Commit           kimwitu++            Bullet              tramp3d-v4          7zip                 geomean
C 		29cd42cab9       49485M (+0.23%)      112040M (+0.05%)    109687M (+0.46%)    227685M (+0.17%)     73023M (+0.10%)
C 		252f292ed2       49371M (+0.50%)      111980M (+0.11%)    109182M (+0.50%)    227293M (+0.98%)     72952M (+0.21%)

Showing this patch on the top, and the previous one on the bottom. I have omitted most test cases as they show essentially no difference.
These are number for optimized (O3) builds.

So most of our hit is coming from the previous patch, which I am working to improve. And I think there is still a lot of things that can be tried on this patch to get that number even lower.

Applying all the rest of the resugaring patches, up to the third one, increases the worst case by an additional 0.25%. Most test cases still show essentially no change.

You can see these numbers at http://llvm-compile-time-tracker.com/?config=NewPM-O3&stat=instructions%3Au&remote=mizvekov.

I am inclined to think that, for now, we will not need to offer an option to turn resugaring off, on performance grounds.

clang-tools-extra/clang-tidy/readability/QualifiedAutoCheck.cpp

auto ExplicitSingleVarDeclInTemplate =
             hasSingleDecl(
                 varDecl(unless(isImplicit()), InnerMatcher).bind(ID)));
       };
 
   auto IsBoundToType = refersToType(equalsBoundNode("type"));
   auto UnlessFunctionType = unless(hasUnqualifiedDesugaredType(functionType()));
   auto IsAutoDeducedToPointer = [](const auto &...InnerMatchers) {
     return autoType(hasDeducedType(
-        hasUnqualifiedDesugaredType(pointerType(pointee(InnerMatchers...)))));
+        hasCanonicalType(pointerType(pointee(InnerMatchers...)))));
   };
 
   Finder->addMatcher(
       ExplicitSingleVarDecl(hasType(IsAutoDeducedToPointer(UnlessFunctionType)),
                             "auto"),
       this);
 
   Finder->addMatcher(

clang/include/clang/AST/TypeLoc.h

void initializeLocal(ASTContext &Context, SourceLocation loc) {
     setAttr(nullptr);
   }
 
   QualType getInnerType() const {
     return getTypePtr()->getModifiedType();
   }
 };
 
-struct BTFTagAttributedLocInfo {}; // Nothing.
+struct alignas(4) BTFTagAttributedLocInfo {}; // Nothing.
 
 /// Type source information for an btf_tag attributed type.
 class BTFTagAttributedTypeLoc
     : public ConcreteTypeLoc<UnqualTypeLoc, BTFTagAttributedTypeLoc,
                              BTFTagAttributedType, BTFTagAttributedLocInfo> {
 public:
   TypeLoc getWrappedLoc() const { return getInnerTypeLoc(); }
 

clang/include/clang/Basic/LangOptions.h

public:
   /// Indicates whether the __FILE__ macro should use the target's
   /// platform-specific file separator or whether it should use the build
   /// environment's platform-specific file separator.
   ///
   /// The plaform-specific path separator is the backslash(\) for Windows and
   /// forward slash (/) elsewhere.
   bool UseTargetPathSeparator = false;
 
+  /// Resugar template specializations.
+  bool Resugar = true;
+
   LangOptions();
 
   /// Set language defaults for the given input language and
   /// language standard in the given LangOptions object.
   ///
   /// \param Opts - The LangOptions object to set up.
   /// \param Lang - The input language.
   /// \param T - The target triple.

clang/include/clang/Driver/Options.td

 defm recovery_ast : BoolOption<"f", "recovery-ast",
   LangOpts<"RecoveryAST">, DefaultTrue,
   NegFlag<SetFalse>, PosFlag<SetTrue, [], "Preserve expressions in AST rather "
                               "than dropping them when encountering semantic errors">>;
 defm recovery_ast_type : BoolOption<"f", "recovery-ast-type",
   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 {
 
 def Eonly : Flag<["-"], "Eonly">,
   HelpText<"Just run preprocessor, no output (for timings)">;
 def dump_raw_tokens : Flag<["-"], "dump-raw-tokens">,
   HelpText<"Lex file in raw mode and dump raw tokens">;
 def analyze : Flag<["-"], "analyze">,

clang/include/clang/Sema/Sema.h

bool checkMSInheritanceAttrOnDefinition(
       CXXRecordDecl *RD, SourceRange Range, bool BestCase,
       MSInheritanceModel SemanticSpelling);
 
   void CheckAlignasUnderalignment(Decl *D);
 
   /// Adjust the calling convention of a method to be the ABI default if it
   /// wasn't specified explicitly.  This handles method types formed from
   /// function type typedefs and typename template arguments.
+  /// For deduced types, don't suppress the adjusment even for explicit CC.
   void adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor,
-                              SourceLocation Loc);
+                              bool IsDeduced, SourceLocation Loc);
 
   // Check if there is an explicit attribute, but only look through parens.
   // The intent is to look for an attribute on the current declarator, but not
   // one that came from a typedef.
   bool hasExplicitCallingConv(QualType T);
 
   /// Get the outermost AttributedType node that sets a calling convention.
   /// Valid types should not have multiple attributes with different CCs.
public:
   DeclRefExpr *
   BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
                    const DeclarationNameInfo &NameInfo,
                    NestedNameSpecifierLoc NNS, NamedDecl *FoundD = nullptr,
                    SourceLocation TemplateKWLoc = SourceLocation(),
                    const TemplateArgumentListInfo *TemplateArgs = nullptr,
                    const TemplateArgumentList *ConvertedArgs = 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(
       const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R,
       const TemplateArgumentListInfo *TemplateArgs, const Scope *S,
       UnresolvedLookupExpr *AsULE = nullptr);
   ExprResult BuildImplicitMemberExpr(const CXXScopeSpec &SS,
                                      SourceLocation TemplateKWLoc,
BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc,
                            NamedDecl *FirstQualifierInScope, LookupResult &R,
                            const TemplateArgumentListInfo *TemplateArgs,
                            const Scope *S,
                            bool SuppressQualifierCheck = false,
                            ActOnMemberAccessExtraArgs *ExtraArgs = nullptr);
 
   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);
 
   ExprResult PerformMemberExprBaseConversion(Expr *Base, bool IsArrow);
 
   bool CheckQualifiedMemberReference(Expr *BaseExpr, QualType BaseType,
                                      const CXXScopeSpec &SS,
                                      const LookupResult &R);
public:
 
   void translateTemplateArguments(const ASTTemplateArgsPtr &In,
                                   TemplateArgumentListInfo &Out);
 
   ParsedTemplateArgument ActOnTemplateTypeArgument(TypeResult ParsedType);
 
   void NoteAllFoundTemplates(TemplateName Name);
 
-  QualType CheckTemplateIdType(TemplateName Template,
+  QualType CheckTemplateIdType(const CXXScopeSpec &SS, TemplateName Template,
                                SourceLocation TemplateLoc,
                                TemplateArgumentListInfo &TemplateArgs);
 
   TypeResult
   ActOnTemplateIdType(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
                       TemplateTy Template, IdentifierInfo *TemplateII,
                       SourceLocation TemplateIILoc, SourceLocation LAngleLoc,
                       ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc,
                       bool IsCtorOrDtorName = false, bool IsClassName = false);
 
public:
     const FunctionProtoType::ExtParameterInfo *
     getPointerOrNull(unsigned numParams) {
       if (!HasInteresting) return nullptr;
       Infos.resize(numParams);
       return Infos.data();
     }
   };
 
+  QualType resugar(const CXXScopeSpec &SS, 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<TemplateArgument> Args, QualType T);
+  QualType resugar(const Type *Base, QualType T);
+  QualType resugar(const Type *Base, NamedDecl *ND,
+                   ArrayRef<TemplateArgument> Args, QualType T);
+
   void PerformPendingInstantiations(bool LocalOnly = false);
 
   TypeSourceInfo *SubstType(TypeSourceInfo *T,
                             const MultiLevelTemplateArgumentList &TemplateArgs,
                             SourceLocation Loc, DeclarationName Entity,
                             bool AllowDeducedTST = false);
 
   QualType SubstType(QualType T,

clang/lib/AST/ASTContext.cpp

ASTContext::getSubstTemplateTypeParmType(QualType Replacement,
   }
 
   return QualType(SubstParm, 0);
 }
 
 /// Retrieve a
 QualType ASTContext::getSubstTemplateTypeParmPackType(
     Decl *AssociatedDecl, 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");
 #endif
 
   llvm::FoldingSetNodeID ID;
   SubstTemplateTypeParmPackType::Profile(ID, AssociatedDecl, Index, ArgPack);
   void *InsertPos = nullptr;

clang/lib/Sema/SemaCXXScopeSpec.cpp

if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(SD)) {
       return false;
     }
 
     if (NamespaceAliasDecl *Alias = dyn_cast<NamespaceAliasDecl>(SD)) {
       SS.Extend(Context, Alias, IdInfo.IdentifierLoc, IdInfo.CCLoc);
       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);
 
     TypeLocBuilder TLB;
     if (const auto *USD = dyn_cast<UsingShadowDecl>(SD)) {
       T = Context.getUsingType(USD, T);
       TLB.pushTypeSpec(T).setNameLoc(IdInfo.IdentifierLoc);
bool Sema::ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS,
   if (SS.isInvalid() || DS.getTypeSpecType() == DeclSpec::TST_error)
     return true;
 
   assert(DS.getTypeSpecType() == DeclSpec::TST_decltype);
 
   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;
     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;
 }
 
 /// IsInvalidUnlessNestedName - This method is used for error recovery
 /// purposes to determine whether the specified identifier is only valid as
 /// a nested name specifier, for example a namespace name.  It is
if (Template.getAsOverloadedTemplate() || DTN ||
     Diag(CCLoc, diag::err_non_type_template_in_nested_name_specifier)
       << (TD && isa<VarTemplateDecl>(TD)) << Template << R;
     NoteAllFoundTemplates(Template);
     return true;
   }
 
   // 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
     = Builder.push<TemplateSpecializationTypeLoc>(T);
   SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
   SpecTL.setTemplateNameLoc(TemplateNameLoc);
   SpecTL.setLAngleLoc(LAngleLoc);
   SpecTL.setRAngleLoc(RAngleLoc);
   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);
   return false;
 }
 
 namespace {
   /// A structure that stores a nested-name-specifier annotation,

clang/lib/Sema/SemaChecking.cpp

bool dumpRecordValue(const RecordDecl *RD, Expr *E, Expr *RecordIndent,
 
     // Dump each field.
     for (auto *D : RD->decls()) {
       auto *IFD = dyn_cast<IndirectFieldDecl>(D);
       auto *FD = IFD ? IFD->getAnonField() : dyn_cast<FieldDecl>(D);
       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()) {
         Format += ": %zu ";
         QualType SizeT = S.Context.getSizeType();
         llvm::APInt BitWidth(S.Context.getIntWidth(SizeT),
                              FD->getBitWidthValue(S.Context));
         Args.push_back(IntegerLiteral::Create(S.Context, BitWidth, SizeT, Loc));
       }
 
       Format += "=";
 
       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.
         if (callPrintFunction(Format, Args) ||
             dumpRecordValue(InnerRD, Field.get(), FieldIndentArg, Depth + 1))
           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 {
           // We don't know how to print this field. Print out its address
           // with a format specifier that a smart tool will be able to
           // recognize and treat specially.
           Format += "*%p";
           ExprResult FieldAddr =

clang/lib/Sema/SemaCoroutine.cpp

if (MD->isInstance()) {
               : S.Context.getLValueReferenceType(T, /*SpelledAsLValue*/ true);
       AddArg(T);
     }
   }
   for (QualType T : FnType->getParamTypes())
     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,
                             diag::err_coroutine_type_missing_specialization))
     return QualType();
 
   auto *RD = CoroTrait->getAsCXXRecordDecl();
   assert(RD && "specialization of class template is not a class?");
static QualType lookupCoroutineHandleType(Sema &S, QualType PromiseType,
 
   // Form template argument list for coroutine_handle<Promise>.
   TemplateArgumentListInfo Args(Loc, Loc);
   Args.addArgument(TemplateArgumentLoc(
       TemplateArgument(PromiseType),
       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,
                             diag::err_coroutine_type_missing_specialization))
     return QualType();
 
   return CoroHandleType;
 }

clang/lib/Sema/SemaDecl.cpp

if (!isClassName && !IsCtorOrDtorName && LookupRD && FoundRD &&
         FoundRD->isInjectedClassName() &&
         declaresSameEntity(LookupRD, cast<Decl>(FoundRD->getParent())))
       Diag(NameLoc, diag::err_out_of_line_qualified_id_type_names_constructor)
           << &II << /*Type*/1;
 
     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);
     if (!HasTrailingDot)
       T = Context.getObjCInterfaceType(IDecl);
     FoundUsingShadow = nullptr; // FIXME: Target must be a TypeDecl.
   } else if (auto *UD = dyn_cast<UnresolvedUsingIfExistsDecl>(IIDecl)) {
     (void)DiagnoseUseOfDecl(UD, NameLoc);
Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
 
   if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec())
     Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
          diag::err_invalid_thread)
       << DeclSpec::getSpecifierName(TSCS);
 
   if (D.isFirstDeclarationOfMember())
     adjustMemberFunctionCC(R, D.isStaticMember(), D.isCtorOrDtor(),
-                           D.getIdentifierLoc());
+                           /*isDeduced=*/false, D.getIdentifierLoc());
 
   bool isFriend = false;
   FunctionTemplateDecl *FunctionTemplate = nullptr;
   bool isMemberSpecialization = false;
   bool isFunctionTemplateSpecialization = false;
 
   bool isDependentClassScopeExplicitSpecialization = false;
   bool HasExplicitTemplateArgs = false;
bool Sema::DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit,
   QualType DeducedType = deduceVarTypeFromInitializer(
       VDecl, VDecl->getDeclName(), VDecl->getType(), VDecl->getTypeSourceInfo(),
       VDecl->getSourceRange(), DirectInit, Init);
   if (DeducedType.isNull()) {
     VDecl->setInvalidDecl();
     return true;
   }
 
+  // FIXME: Set TypeSourceInfo?
   VDecl->setType(DeducedType);
   assert(VDecl->isLinkageValid());
 
   // In ARC, infer lifetime.
   if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(VDecl))
     VDecl->setInvalidDecl();
 
   if (getLangOpts().OpenCL)

clang/lib/Sema/SemaDeclAttr.cpp

static void handleCleanupAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   if (FD->getNumParams() != 1) {
     S.Diag(Loc, diag::err_attribute_cleanup_func_must_take_one_arg)
       << NI.getName();
     return;
   }
 
   // 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(),
                                    ParamTy, Ty) != Sema::Compatible) {
     S.Diag(Loc, diag::err_attribute_cleanup_func_arg_incompatible_type)
       << NI.getName() << ParamTy << Ty;
     return;
   }

clang/lib/Sema/SemaDeclCXX.cpp

if (!TraitTD) {
     Result.suppressDiagnostics();
     NamedDecl *Found = *Result.begin();
     S.Diag(Loc, diag::err_std_type_trait_not_class_template) << Trait;
     S.Diag(Found->getLocation(), diag::note_declared_at);
     return true;
   }
 
   // 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)) {
     if (DiagID)
       S.RequireCompleteType(
           Loc, TraitTy, DiagID,
           printTemplateArgs(S.Context.getPrintingPolicy(), Args,
                             TraitTD->getTemplateParameters()));
static bool checkMemberDecomposition(Sema &S, ArrayRef<BindingDecl*> Bindings,
   //   all of E's non-static data members shall be [...] well-formed
   //   when named as e.name in the context of the structured binding,
   //   E shall not have an anonymous union member, ...
   unsigned I = 0;
   for (auto *FD : RD->fields()) {
     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()) {
       if (RD->isLambda()) {
         S.Diag(Src->getLocation(), diag::err_decomp_decl_lambda);
         S.Diag(RD->getLocation(), diag::note_lambda_decl);
         return true;
       }
 
       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;
       }
 
       // FIXME: Are there any other ways we could have an anonymous member?
     }
 
     // We have a real field to bind.
for (auto *FD : RD->fields()) {
     ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
     if (E.isInvalid())
       return true;
     E = S.ImpCastExprToType(E.get(), BaseType, CK_UncheckedDerivedToBase,
                             VK_LValue, &BasePath);
     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())
       return true;
 
     // If the type of the member is T, the referenced type is cv T, where cv is
     // the cv-qualification of the decomposition expression.
     //
     // FIXME: We resolve a defect here: if the field is mutable, we do not add
     // 'const' to the type of the field.
     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())
     return DiagnoseBadNumberOfBindings();
 
   return false;
 }
 
private:
 
   ExprPair getField(FieldDecl *Field) {
     ExprPair Obj = getCompleteObject();
     if (Obj.first.isInvalid() || Obj.second.isInvalid())
       return {ExprError(), ExprError()};
 
     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
   // stack to say which subobject we're comparing.
 
   StmtResult buildIfNotCondReturnFalse(ExprResult Cond) {
     if (Cond.isInvalid())
       return StmtError();
QualType Sema::BuildStdInitializerList(QualType Element, SourceLocation Loc) {
 
   TemplateArgumentListInfo Args(Loc, Loc);
   Args.addArgument(TemplateArgumentLoc(TemplateArgument(Element),
                                        Context.getTrivialTypeSourceInfo(Element,
                                                                         Loc)));
   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) {
   // C++ [dcl.init.list]p2:
   //   A constructor is an initializer-list constructor if its first parameter
   //   is of type std::initializer_list<E> or reference to possibly cv-qualified
   //   std::initializer_list<E> for some type E, and either there are no other
   //   parameters or else all other parameters have default arguments.

clang/lib/Sema/SemaExpr.cpp

 ExprResult Sema::BuildDeclarationNameExpr(const CXXScopeSpec &SS,
                                           LookupResult &R, bool NeedsADL,
                                           bool AcceptInvalidDecl) {
   // If this is a single, fully-resolved result and we don't need ADL,
   // just build an ordinary singleton decl ref.
   if (!NeedsADL && R.isSingleResult() &&
       !R.getAsSingle<FunctionTemplateDecl>() &&
       !ShouldLookupResultBeMultiVersionOverload(R))
+    // FIXME: get ConvertedArgs
     return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), R.getFoundDecl(),
                                     R.getRepresentativeDecl(), nullptr, nullptr,
                                     AcceptInvalidDecl);
 
   // We only need to check the declaration if there's exactly one
   // result, because in the overloaded case the results can only be
   // functions and function templates.
   if (R.isSingleResult() && !ShouldLookupResultBeMultiVersionOverload(R) &&
ExprResult Sema::BuildDeclarationNameExpr(
   if (IndirectFieldDecl *indirectField = dyn_cast<IndirectFieldDecl>(VD))
     if (!indirectField->isCXXClassMember())
       return BuildAnonymousStructUnionMemberReference(SS, NameInfo.getLoc(),
                                                       indirectField);
 
   QualType type = VD->getType();
   if (type.isNull())
     return ExprError();
+  assert(!TemplateArgs || ConvertedArgs);
+  type = ConvertedArgs ? resugar(SS, VD, ConvertedArgs->asArray(), type)
+                       : resugar(SS, type);
   ExprValueKind valueKind = VK_PRValue;
 
   // In 'T ...V;', the type of the declaration 'V' is 'T...', but the type of
   // a reference to 'V' is simply (unexpanded) 'T'. The type, like the value,
   // is expanded by some outer '...' in the context of the use.
   type = type.getNonPackExpansionType();
 
   switch (D->getKind()) {
#include "clang/AST/DeclNodes.inc"
 
   case Decl::Binding:
     // These are always lvalues.
     valueKind = VK_LValue;
     type = type.getNonReferenceType();
     break;
 
   case Decl::Function: {
     if (unsigned BID = cast<FunctionDecl>(VD)->getBuiltinID()) {
       if (!Context.BuiltinInfo.isDirectlyAddressable(BID)) {
         type = Context.BuiltinFnTy;
         valueKind = VK_PRValue;
         break;
       }
     }
 
     const FunctionType *fty = type->castAs<FunctionType>();
 
     // If we're referring to a function with an __unknown_anytype
     // result type, make the entire expression __unknown_anytype.
if (TryInstantiating) {
         // Do not defer instantiations of variables that could be used in a
         // constant expression.
         SemaRef.runWithSufficientStackSpace(PointOfInstantiation, [&] {
           SemaRef.InstantiateVariableDefinition(PointOfInstantiation, Var);
         });
 
         // 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());
+          assert(DRE->template_arguments().size() == 0 ||
+                 DRE->getConvertedArgs() != nullptr);
+          QualType T = DRE->getConvertedArgs()
+                           ? SemaRef.resugar(SS, DRE->getDecl(),
+                                             DRE->getConvertedArgs()->asArray(),
+                                             DRE->getType())
+                           : SemaRef.resugar(SS, DRE->getType());
+          DRE->setType(T);
+        } else if (auto *ME = dyn_cast_or_null<MemberExpr>(E)) {
           ME->setMemberDecl(ME->getMemberDecl());
+          SS.Adopt(ME->getQualifierLoc());
+          assert(ME->template_arguments().size() == 0 ||
+                 ME->getDeduced() != nullptr);
+          QualType T =
+              ME->getDeduced()
+                  ? SemaRef.resugar(SS, ME->getMemberDecl(),
+                                    ME->getDeduced()->asArray(), ME->getType())
+                  : SemaRef.resugar(SS, ME->getType());
+          ME->setType(T);
+        }
       } else if (FirstInstantiation ||
                  isa<VarTemplateSpecializationDecl>(Var)) {
         // FIXME: For a specialization of a variable template, we don't
         // distinguish between "declaration and type implicitly instantiated"
         // and "implicit instantiation of definition requested", so we have
         // no direct way to avoid enqueueing the pending instantiation
         // multiple times.
         SemaRef.PendingInstantiations
if (DRE) {
                                         /*DefinitionRequired=*/true,
                                         /*AtEndOfTU=*/false);
         }
         // Produce a properly-typed reference to the function.
         CXXScopeSpec SS;
         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(),
             DRE->getTemplateKeywordLoc(),
             DRE->hasExplicitTemplateArgs() ? &TemplateArgs : nullptr,
             DRE->getConvertedArgs());
       }
     }

clang/lib/Sema/SemaExprMember.cpp

Sema::BuildMemberReferenceExpr(Expr *Base, QualType BaseType,
   }
 
   return BuildMemberReferenceExpr(Base, BaseType,
                                   OpLoc, IsArrow, SS, TemplateKWLoc,
                                   FirstQualifierInScope, R, TemplateArgs, S,
                                   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());
 
     // In principle we could have a member access expression that
     // accesses an anonymous struct/union that's a static member of
     // the base object's class.  However, under the current standard,
     // static data members cannot be anonymous structs or unions.
     // Supporting this is as easy as building a MemberExpr here.
     assert(!baseObjectExpr && "anonymous struct/union is static data member?");
 
     DeclarationNameInfo baseNameInfo(DeclarationName(), loc);
 
+    CXXScopeSpec EmptySS;
     ExprResult result
       = BuildDeclarationNameExpr(EmptySS, baseNameInfo, baseVariable);
     if (result.isInvalid()) return ExprError();
 
     baseObjectExpr = result.get();
   }
 
   assert((baseVariable || baseObjectExpr) &&
          "referencing anonymous struct/union without a base variable or "
          "expression");
 
   // Build the implicit member references to the field of the
   // anonymous struct/union.
   Expr *result = baseObjectExpr;
   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) {
     FieldDecl *field = cast<FieldDecl>(*FI);
 
     bool baseObjectIsPointer = baseObjectExpr->getType()->isPointerType();
 
     // 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)
+    result = BuildFieldReferenceExpr(result, baseObjectIsPointer,
+                                     SourceLocation(), NNS, field, FieldType,
+                                     foundDecl, memberNameInfo)
                  .get();
     if (!result)
       return ExprError();
   }
 
   // In all cases, we should now skip the first declaration in the chain.
   ++FI;
 
   while (FI != FEnd) {
     FieldDecl *field = cast<FieldDecl>(*FI++);
 
     // FIXME: these are somewhat meaningless
     DeclarationNameInfo memberNameInfo(field->getDeclName(), loc);
     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();
   }
 
   return result;
 }
 
 static ExprResult
 BuildMSPropertyRefExpr(Sema &S, Expr *BaseExpr, bool IsArrow,
if (SS.getRange().isValid())
       Loc = SS.getRange().getBegin();
     BaseExpr = BuildCXXThisExpr(Loc, BaseExprType, /*IsImplicit=*/true);
   }
 
   // Check the use of this member.
   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());
+    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()) {
       valueKind = VK_PRValue;
       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)) {
     if (!TemplateArgs) {
       diagnoseMissingTemplateArguments(TemplateName(VarTempl), MemberLoc);
       return ExprError();
     }
 
if (!VDecl.get())
       return ActOnDependentMemberExpr(
           BaseExpr, BaseExpr->getType(), IsArrow, OpLoc, SS, TemplateKWLoc,
           FirstQualifierInScope, MemberNameInfo, TemplateArgs);
 
     VarDecl *Var = cast<VarDecl>(VDecl.get());
     if (!Var->getTemplateSpecializationKind())
       Var->setTemplateSpecializationKind(TSK_ImplicitInstantiation, MemberLoc);
 
-    return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Var,
+    NestedNameSpecifierLoc NNS = SS.getWithLocInContext(Context);
+    QualType VarType = resugar(BaseType.getTypePtr(), NNS, Var,
+                               ConvertedArgs->asArray(), Var->getType());
+    return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, NNS, TemplateKWLoc, Var,
                            FoundDecl, /*HadMultipleCandidates=*/false,
-                           MemberNameInfo, Var->getType().getNonReferenceType(),
+                           MemberNameInfo, VarType.getNonReferenceType(),
                            VK_LValue, OK_Ordinary, TemplateArgs, ConvertedArgs);
   }
 
   // We found something that we didn't expect. Complain.
   if (isa<TypeDecl>(MemberDecl))
     Diag(MemberLoc, diag::err_typecheck_member_reference_type)
       << MemberName << BaseType << int(IsArrow);
   else
if (ResultTy->isArrayType()) {
     if (const auto *Ptr = dyn_cast<PointerType>(
             E->getBase()->getType().getDesugaredType(Context))) {
       if (Ptr->getPointeeType()->hasAttr(attr::NoDeref))
         ExprEvalContexts.back().PossibleDerefs.insert(E);
     }
   }
 }
 
-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
   //   an ordinary object then we must have an rvalue.
   ExprValueKind VK = VK_LValue;
   ExprObjectKind OK = OK_Ordinary;
   if (!IsArrow) {
     if (BaseExpr->getObjectKind() == OK_Ordinary)
       VK = BaseExpr->getValueKind();
     else
       VK = VK_PRValue;
   }
   if (VK != VK_PRValue && Field->isBitField())
     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();
     if (IsArrow) BaseType = BaseType->castAs<PointerType>()->getPointeeType();
 
     Qualifiers BaseQuals = BaseType.getQualifiers();
 
     // GC attributes are never picked up by members.
     BaseQuals.removeObjCGCAttr();
 
     // CVR attributes from the base are picked up by members,
     // except that 'mutable' members don't pick up 'const'.
     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();
 
   // Build a reference to a private copy for non-static data members in
   // non-static member functions, privatized by OpenMP constructs.
   if (getLangOpts().OpenMP && IsArrow &&
       !CurContext->isDependentContext() &&
       isa<CXXThisExpr>(Base.get()->IgnoreParenImpCasts())) {
     if (auto *PrivateCopy = isOpenMPCapturedDecl(Field)) {
       return getOpenMPCapturedExpr(PrivateCopy, VK, OK,
                                    MemberNameInfo.getLoc());
     }
   }
 
-  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
 /// is known to be an instance method, and the given unqualified lookup
 /// set is known to contain only instance members, at least one of which
 /// is from an appropriate type.
 ExprResult
 Sema::BuildImplicitMemberExpr(const CXXScopeSpec &SS,

clang/lib/Sema/SemaInit.cpp

case OR_Success:
     }
 
     // Make sure we didn't select an unusable deduction guide, and mark it
     // as referenced.
     DiagnoseUseOfDecl(Best->Function, Kind.getLocation());
     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;
 
   // Warn if CTAD was used on a type that does not have any user-defined
   // deduction guides.
   if (!HasAnyDeductionGuide) {
     Diag(TSInfo->getTypeLoc().getBeginLoc(),
          diag::warn_ctad_maybe_unsupported)
         << TemplateName;
     Diag(Template->getLocation(), diag::note_suppress_ctad_maybe_unsupported);
   }
 
   return DeducedType;
 }

clang/lib/Sema/SemaOverload.cpp

static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
   if (FromType == S.Context.OverloadTy) {
     DeclAccessPair AccessPair;
     const TemplateArgumentList *ConvertedArgs;
     if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(
             From, ToType, false, AccessPair, ConvertedArgs)) {
       // We were able to resolve the address of the overloaded function,
       // so we can convert to the type of that function.
       FromType = Fn->getType();
+      // FIXME: resugar
       SCS.setFromType(FromType);
 
       // we can sometimes resolve &foo<int> regardless of ToType, so check
       // if the type matches (identity) or we are converting to bool
       if (!S.Context.hasSameUnqualifiedType(
                       S.ExtractUnqualifiedFunctionType(ToType), FromType)) {
         QualType resultTy;
         // if the function type matches except for [[noreturn]], it's ok
TryReferenceInit(Sema &S, Expr *Init, QualType DeclType,
   // If the initializer is the address of an overloaded function, try
   // to resolve the overloaded function. If all goes well, T2 is the
   // type of the resulting function.
   if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
     DeclAccessPair Found;
     const TemplateArgumentList *ConvertedArgs;
     if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(
             Init, DeclType, false, Found, ConvertedArgs))
+      // FIXME: resugar
       T2 = Fn->getType();
   }
 
   // Compute some basic properties of the types and the initializer.
   bool isRValRef = DeclType->isRValueReferenceType();
   Expr::Classification InitCategory = Init->Classify(S.Context);
 
   Sema::ReferenceConversions RefConv;
if (From->getNumInits() == 1) {
       // If the initializer is the address of an overloaded function, try
       // to resolve the overloaded function. If all goes well, T2 is the
       // type of the resulting function.
       if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
         DeclAccessPair Found;
         const TemplateArgumentList *ConvertedArgs;
         if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(
                 Init, ToType, false, Found, ConvertedArgs))
+          // FIXME: resugar
           T2 = Fn->getType();
       }
 
       // Compute some basic properties of the types and the initializer.
       Sema::ReferenceCompareResult RefRelationship =
           S.CompareReferenceRelationship(From->getBeginLoc(), T1, T2);
 
       if (RefRelationship >= Sema::Ref_Related) {
if (!Found || Found->isCPUDispatchMultiVersion() ||
       Found->isCPUSpecificMultiVersion())
     return false;
 
   // Emitting multiple diagnostics for a function that is both inaccessible and
   // unavailable is consistent with our behavior elsewhere. So, always check
   // for both.
   DiagnoseUseOfDecl(Found, E->getExprLoc());
   CheckAddressOfMemberAccess(E, DAP);
+  // FIXME: resugar
   Expr *Fixed = FixOverloadedFunctionReference(E, DAP, Found, nullptr);
   if (DoFunctionPointerConversion && Fixed->getType()->isFunctionType())
     SrcExpr = DefaultFunctionArrayConversion(Fixed, /*Diagnose=*/false);
   else
     SrcExpr = Fixed;
   return true;
 }
 
if (isa<MemberExpr>(NakedMemExpr)) {
     // non-member call based on that function.
     if (Method->isStatic()) {
       return BuildResolvedCallExpr(MemExprE, Method, LParenLoc, Args, RParenLoc,
                                    ExecConfig, IsExecConfig);
     }
 
     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).
   // We only need to do this if there was actually an overload; otherwise
   // it was done at lookup.
   if (!Method->isStatic()) {
     ExprResult ObjectArg =
       PerformObjectArgumentInitialization(MemExpr->getBase(), Qualifier,
if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
         assert(isa<DeclRefExpr>(SubExpr)
                && "fixed to something other than a decl ref");
         assert(cast<DeclRefExpr>(SubExpr)->getQualifier()
                && "fixed to a member ref with no nested name qualifier");
 
         // 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);
 
         return UnaryOperator::Create(
             Context, SubExpr, UO_AddrOf, MemPtrType, VK_PRValue, OK_Ordinary,
             UnOp->getOperatorLoc(), false, CurFPFeatureOverrides());
       }
Sema::FixOverloadedFunctionReference(Expr *E, DeclAccessPair Found,
 
   if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
     // FIXME: avoid copy.
     TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
     if (ULE->hasExplicitTemplateArgs()) {
       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, Deduced);
+        Fn, Type, ValueKind, ULE->getNameInfo(), NNS, Found.getDecl(),
+        ULE->getTemplateKeywordLoc(), TemplateArgs, Deduced);
     DRE->setHadMultipleCandidates(ULE->getNumDecls() > 1);
     return DRE;
   }
 
   if (UnresolvedMemberExpr *MemExpr = dyn_cast<UnresolvedMemberExpr>(E)) {
     // FIXME: avoid copy.
     TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
     if (MemExpr->hasExplicitTemplateArgs()) {
       MemExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
       TemplateArgs = &TemplateArgsBuffer;
     }
+    QualType BaseType = MemExpr->getBaseType();
+    const Type *BasePointeeType = BaseType->getPointeeType().getTypePtrOrNull();
+    if (!BasePointeeType)
+      BasePointeeType = BaseType.getTypePtr();
 
     Expr *Base;
 
     // If we're filling in a static method where we used to have an
     // implicit member access, rewrite to a simple decl ref.
     if (MemExpr->isImplicitAccess()) {
       if (cast<CXXMethodDecl>(Fn)->isStatic()) {
+        QualType Type = Deduced ? resugar(BasePointeeType, Fn,
+                                          Deduced->asArray(), Fn->getType())
+                                : resugar(BasePointeeType, Fn->getType());
         DeclRefExpr *DRE = BuildDeclRefExpr(
-            Fn, Fn->getType(), VK_LValue, MemExpr->getNameInfo(),
+            Fn, Type, VK_LValue, MemExpr->getNameInfo(),
             MemExpr->getQualifierLoc(), Found.getDecl(),
             MemExpr->getTemplateKeywordLoc(), TemplateArgs, Deduced);
         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,

clang/lib/Sema/SemaTemplate.cpp

 //===------- SemaTemplate.cpp - Semantic Analysis for C++ Templates -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //===----------------------------------------------------------------------===//
 //
 //  This file implements semantic analysis for C++ templates.
 //===----------------------------------------------------------------------===//
 
 #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"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/TemplateName.h"
 #include "clang/AST/TypeVisitor.h"
if (!Info.TemplateParams.empty()) {
       ParamsAtDepth(Info.AutoTemplateParameterDepth);
       break;
     }
   }
 
   return Depth;
 }
 
+TemplateDecl *getTemplateDecl(NamedDecl *D) {
+  switch (D->getKind()) {
+  case Decl::Kind::FunctionTemplate: // FIXME
+    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>;
+
+  using TemplateToArgs =
+      llvm::DenseMap<const Decl *, ArrayRef<TemplateArgument>>;
+  TemplateToArgs CurTemplateToArgs;
+
+  llvm::SmallPtrSet<const TemplateDecl *, 4> EarlySubstitutionSet;
+
+  const TemplateArgument *getArgument(const Decl *ReplacedDecl, unsigned Index,
+                                      Optional<unsigned> PackIndex) const {
+    auto It = CurTemplateToArgs.find(ReplacedDecl);
+    if (It == CurTemplateToArgs.end())
+      return nullptr;
+    ArrayRef<TemplateArgument> Args = It->second;
+    assert(Index < Args.size());
+    const TemplateArgument &Arg = Args[Index];
+    if (!PackIndex)
+      return &Arg;
+    ArrayRef<TemplateArgument> PackArgs = Arg.getPackAsArray();
+    assert(*PackIndex < PackArgs.size());
+    return &PackArgs[PackArgs.size() - 1 - *PackIndex];
+  }
+
+public:
+  struct SemanticContextRAII {
+    SemanticContextRAII(Resugarer &R, NamedDecl *ND,
+                        ArrayRef<TemplateArgument> Args)
+        : R(&R) {
+      assert(ND != nullptr);
+      assert(Args.size() != 0);
+      TemplateDecl *TD = getTemplateDecl(ND);
+      assert(TD != nullptr);
+      auto &Entry =
+          R.CurTemplateToArgs.FindAndConstruct(TD->getCanonicalDecl());
+      Old = Entry;
+
+      switch (ND->getKind()) {
+      case Decl::Kind::CXXConversion:
+      case Decl::Kind::CXXMethod:
+      case Decl::Kind::Function:
+        break;
+      case Decl::Kind::VarTemplateSpecialization: {
+        auto *VTPSD = cast<VarTemplateSpecializationDecl>(ND)
+                          ->getSpecializedTemplateOrPartial()
+                          .dyn_cast<VarTemplatePartialSpecializationDecl *>();
+        if (!VTPSD)
+          break;
+        TemplateDeductionInfo Info(SourceLocation{},
+                                   VTPSD->getTemplateParameters()->getDepth());
+        [[maybe_unused]] Sema::TemplateDeductionResult Res =
+            R.SemaRef.DeduceTemplateArguments(
+                VTPSD,
+                TemplateArgumentList(TemplateArgumentList::OnStackType{}, Args),
+                Info);
+        assert(Res == Sema::TDK_Success);
+        Entry.second = Info.takeSugared()->asArray();
+        return;
+      }
+      default:
+        ND->dumpColor();
+        llvm_unreachable("Unhandled Template Kind");
+      }
+      Entry.second = Args;
+    }
+    ~SemanticContextRAII() {
+      auto It = R->CurTemplateToArgs.find(Old.first);
+      assert(It != R->CurTemplateToArgs.end());
+      if (Old.second.empty()) {
+        R->CurTemplateToArgs.erase(It);
+        return;
+      }
+      It->second = Old.second;
+    }
+
+  private:
+    Resugarer *R;
+    TemplateToArgs::value_type Old;
+  };
+
+  struct EarlySubstitutionContext {
+    EarlySubstitutionContext(Resugarer &R, const TemplateDecl *TD) : R(&R) {
+      assert(TD != nullptr);
+      switch (TD->getKind()) {
+      case Decl::Kind::BuiltinTemplate:
+      case Decl::Kind::ClassTemplate:
+      case Decl::Kind::TemplateTemplateParm:
+      case Decl::Kind::TypeAliasTemplate:
+        break;
+      default:
+        TD->dumpColor();
+        llvm_unreachable("Unhandled Template Kind");
+      }
+      if (R.EarlySubstitutionSet.insert(TD).second)
+        D = TD;
+    }
+    ~EarlySubstitutionContext() {
+      if (!D)
+        return;
+      [[maybe_unused]] bool Removed = R->EarlySubstitutionSet.erase(D);
+      assert(Removed);
+    }
+    constexpr operator bool() const { return D != nullptr; }
+
+  private:
+    Resugarer *R;
+    const TemplateDecl *D = nullptr;
+  };
+
+  struct NamingContextBase {
+    NamingContextBase(Resugarer &R)
+        : R(&R), OldTemplateToArgs(std::move(R.CurTemplateToArgs)) {}
+    ~NamingContextBase() {
+      R->CurTemplateToArgs = std::move(OldTemplateToArgs);
+    }
+
+  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);
+          assert(Res == Sema::TDK_Success);
+          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;
+
+  protected:
+    TemplateToArgs OldTemplateToArgs;
+  };
+
+  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) {
+    const SubstTemplateTypeParmType *T = TL.getTypePtr();
+    Decl *ReplacedDecl = T->getAssociatedDecl();
+    Optional<unsigned> PackIndex = T->getPackIndex();
+    QualType Replacement = T->getReplacementType();
+    if (const auto *TD = dyn_cast<TemplateDecl>(ReplacedDecl);
+        TD && EarlySubstitutionSet.contains(TD)) {
+      Replacement = TransformType(T->getReplacementType());
+    } else if (const TemplateArgument *Arg =
+                   getArgument(ReplacedDecl, T->getIndex(), PackIndex)) {
+      Replacement = Arg->getAsType().getNonPackExpansionType();
+      if (!SemaRef.Context.hasSameType(Replacement, T->getReplacementType())) {
+        Replacement.dump();
+        T->getReplacementType().dump();
+        assert(false);
+      }
+    }
+
+    QualType QT = TL.getType();
+    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);
+
+    TemplateDecl *TD;
+    if (const auto *S = N.getAsSubstTemplateTemplateParmPack())
+      TD = S->getParameterPack();
+    else
+      TD = N.getAsTemplateDecl();
+
+    auto ConvertedArgs = SmallVector<TemplateArgument, 4>(
+        llvm::iterator_range<const TemplateArgument *>(
+            T->getConvertedArguments()));
+    QualType Underlying = T->desugar();
+    if (EarlySubstitutionContext SemanticScope(*this, TD); SemanticScope) {
+      TransformTemplateArguments(ConvertedArgs);
+      if (T->isTypeAlias())
+        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();
+    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();
+    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<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<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<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);
+
+  TemplateDecl *TD;
+  if (const auto *S = Template.getAsSubstTemplateTemplateParmPack())
+    TD = S->getParameterPack();
+  else
+    TD = Template.getAsTemplateDecl();
+
+  bool IsTypeAlias = !Underlying.isNull() && TD && TD->isTypeAlias();
+
+  Resugarer R(S);
+  Resugarer::NamingContextRAII NamingScope(R, SS.getScopeRep());
+  R.TransformTemplateArguments(SpecArgs);
+  Resugarer::EarlySubstitutionContext SemanticScope(R, TD);
+  assert(SemanticScope);
+  R.TransformTemplateArguments(SugaredConvertedArgs);
+  if (IsTypeAlias)
+    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.
 ///
 /// Note that this may return an UnresolvedUsingValueDecl if AllowDependent
 /// is true. In all other cases it will return a TemplateDecl (or null).
 NamedDecl *Sema::getAsTemplateNameDecl(NamedDecl *D,
                                        bool AllowFunctionTemplates,
for (OverloadedTemplateStorage::iterator I = OST->begin(),
       Diag((*I)->getLocation(), diag::note_template_declared_here)
         << 0 << (*I)->getDeclName();
 
     return;
   }
 }
 
 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();
 
   TemplateParameterList *TPL = BTD->getTemplateParameters();
 
   // Wrap the type in substitution sugar.
   auto getSubstType = [&](QualType Replacement, unsigned IndexReplaced,
case BTK__make_integer_seq: {
 
     // Wrap the template in substitution sugar.
     TemplateName TN = SemaRef.Context.getSubstTemplateTemplateParm(
         cast<TemplateTemplateParmDecl>(TPL->getParam(0)),
         SugaredConverted[0].getAsTemplate());
 
     // 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:
     // Specializations of
     //    __type_pack_element<Index, T_1, ..., T_N>
     // are treated like T_Index.
     assert(SugaredConverted.size() == 2 &&
            "__type_pack_element should be given an index and a parameter pack");
case BTK__type_pack_element:
     if (Index >= Ts.pack_size()) {
       SemaRef.Diag(TemplateArgs[0].getLocation(),
                    diag::err_type_pack_element_out_of_bounds);
       return QualType();
     }
 
     // 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!");
 }
 
 /// Determine whether this alias template is "enable_if_t".
 /// libc++ >=14 uses "__enable_if_t" in C++11 mode.
 static bool isEnableIfAliasTemplate(TypeAliasTemplateDecl *AliasTemplate) {
   return AliasTemplate->getName().equals("enable_if_t") ||
std::string Description;
     PrintingPolicy Policy = getPrintingPolicy();
     Policy.PrintCanonicalTypes = true;
     FailedBooleanConditionPrinterHelper Helper(Policy);
     FailedCond->printPretty(Out, &Helper, Policy, 0, "\n", nullptr);
   }
   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
     = Name.getUnderlying().getAsDependentTemplateName();
   if (DTN && DTN->isIdentifier())
     // When building a template-id where the template-name is dependent,
     // assume the template is a type template. Either our assumption is
     // correct, or the code is ill-formed and will be diagnosed when the
if (CanonType.isNull()) {
                 << FailedCond->getSourceRange());
           }
         }
       }
 
       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,
   } else if (Name.isDependent() ||
              TemplateSpecializationType::anyDependentTemplateArguments(
                  TemplateArgs, CanonicalConverted)) {
     // This class template specialization is a dependent
     // type. Therefore, its canonical type is another class template
     // specialization type that contains all of the converted
     // arguments in canonical form. This ensures that, e.g., A<T> and
     // A<T, T> have identical types when A is declared as:
assert(isa<RecordType>(CanonType) &&
            "type of non-dependent specialization is not a RecordType");
   } else {
     llvm_unreachable("Unhandled template kind");
   }
 
   // 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,
 }
 
 void Sema::ActOnUndeclaredTypeTemplateName(Scope *S, TemplateTy &ParsedName,
                                            TemplateNameKind &TNK,
                                            SourceLocation NameLoc,
                                            IdentifierInfo *&II) {
   assert(TNK == TNK_Undeclared_template && "not an undeclared template name");
 
if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
     SpecTL.setTemplateNameLoc(TemplateIILoc);
     SpecTL.setLAngleLoc(LAngleLoc);
     SpecTL.setRAngleLoc(RAngleLoc);
     for (unsigned I = 0, N = SpecTL.getNumArgs(); I != N; ++I)
       SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
     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;
 
   // Build type-source information.
   TypeLocBuilder TLB;
   TemplateSpecializationTypeLoc SpecTL =
       TLB.push<TemplateSpecializationTypeLoc>(SpecTy);
   SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
if (TypeAliasTemplateDecl *TAT =
     //   If the identifier resolves to a typedef-name or the simple-template-id
     //   resolves to an alias template specialization, the
     //   elaborated-type-specifier is ill-formed.
     Diag(TemplateLoc, diag::err_tag_reference_non_tag)
         << TAT << NTK_TypeAliasTemplate << TagKind;
     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);
   SpecTL.setRAngleLoc(RAngleLoc);
   for (unsigned i = 0, e = SpecTL.getNumArgs(); i != e; ++i)
     SpecTL.setArgLocInfo(i, TemplateArgs[i].getLocInfo());
 
   // 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,
                                              NamedDecl *PrevDecl,
                                              SourceLocation Loc,
                                              bool IsPartialSpecialization);
 
 static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D);
Sema::CheckVarTemplateId(VarTemplateDecl *Template, SourceLocation TemplateLoc,
   ConvertedArgs = TemplateArgumentList::CreateCopy(Context, SugaredConverted);
 
   // Find the variable template specialization declaration that
   // corresponds to these arguments.
   void *InsertPos = nullptr;
   if (VarTemplateSpecializationDecl *Spec =
           Template->findSpecialization(CanonicalConverted, InsertPos)) {
     checkSpecializationReachability(TemplateNameLoc, Spec);
+    // FIXME: We should actually deduce partial specializations again.
+    ConvertedArgs = TemplateArgumentList::CreateCopy(Context, SugaredConverted);
     // If we already have a variable template specialization, return it.
     return Spec;
   }
 
   // This is the first time we have referenced this variable template
   // specialization. Create the canonical declaration and add it to
   // the set of specializations, based on the closest partial specialization
   // that it represents. That is,
if (Matched.size() >= 1) {
 
     // Instantiate using the best variable template partial specialization.
     InstantiationPattern = Best->Partial;
     InstantiationArgs = Best->CanonicalArgs;
   } else {
     //   -- If no match is found, the instantiation is generated
     //      from the primary template.
     // InstantiationPattern = Template->getTemplatedDecl();
+    ConvertedArgs = TemplateArgumentList::CreateCopy(Context, SugaredConverted);
   }
 
   // 2. Create the canonical declaration.
   // Note that we do not instantiate a definition until we see an odr-use
   // in DoMarkVarDeclReferenced().
   // FIXME: LateAttrs et al.?
   VarTemplateSpecializationDecl *Decl = BuildVarTemplateInstantiation(
       Template, InstantiationPattern, *InstantiationArgs, TemplateArgs,
if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
     SpecTL.setTemplateNameLoc(TemplateIILoc);
     SpecTL.setLAngleLoc(LAngleLoc);
     SpecTL.setRAngleLoc(RAngleLoc);
     for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
       SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
     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;
 
   // Provide source-location information for the template specialization type.
   TypeLocBuilder Builder;
   TemplateSpecializationTypeLoc SpecTL
     = Builder.push<TemplateSpecializationTypeLoc>(T);
   SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
   SpecTL.setTemplateNameLoc(TemplateIILoc);
   SpecTL.setLAngleLoc(LAngleLoc);
   SpecTL.setRAngleLoc(RAngleLoc);
   for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
     SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
 
   T = Context.getElaboratedType(ETK_Typename, SS.getScopeRep(), T);
   ElaboratedTypeLoc TL = Builder.push<ElaboratedTypeLoc>(T);
   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));
 }
 
 
 /// Determine whether this failed name lookup should be treated as being
 /// disabled by a usage of std::enable_if.
 static bool isEnableIf(NestedNameSpecifierLoc NNS, const IdentifierInfo &II,
                        SourceRange &CondRange, Expr *&Cond) {
   // We must be looking for a ::type...
if (TypeDecl *Type = dyn_cast<TypeDecl>(Result.getFoundDecl())) {
           FoundRD->isInjectedClassName() &&
           declaresSameEntity(LookupRD, cast<Decl>(FoundRD->getParent())))
         Diag(IILoc, diag::ext_out_of_line_qualified_id_type_names_constructor)
             << &II << 1 << 0 /*'typename' keyword used*/;
 
       // 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:
     //   A type-specifier of the form
     //     typename[opt] nested-name-specifier[opt] template-name
     //   is a placeholder for a deduced class type [...].
     if (getLangOpts().CPlusPlus17) {
       if (auto *TD = getAsTypeTemplateDecl(Result.getFoundDecl())) {

clang/lib/Sema/SemaTemplateDeduction.cpp

case Type::MemberPointer: {
       const auto *MPP = P->castAs<MemberPointerType>(),
                  *MPA = A->getAs<MemberPointerType>();
       if (!MPA)
         return Sema::TDK_NonDeducedMismatch;
 
       QualType PPT = MPP->getPointeeType();
       if (PPT->isFunctionType())
         S.adjustMemberFunctionCC(PPT, /*IsStatic=*/true,
-                                 /*IsCtorOrDtor=*/false, Info.getLocation());
+                                 /*IsCtorOrDtor=*/false, /*isDeduced=*/true,
+                                 Info.getLocation());
       QualType APT = MPA->getPointeeType();
       if (APT->isFunctionType())
         S.adjustMemberFunctionCC(APT, /*IsStatic=*/true,
-                                 /*IsCtorOrDtor=*/false, Info.getLocation());
+                                 /*IsCtorOrDtor=*/false, /*isDeduced=*/true,
+                                 Info.getLocation());
 
       unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
       if (auto Result = DeduceTemplateArgumentsByTypeMatch(
               S, TemplateParams, PPT, APT, Info, Deduced, SubTDF))
         return Result;
       return DeduceTemplateArgumentsByTypeMatch(
           S, TemplateParams, QualType(MPP->getClass(), 0),
           QualType(MPA->getClass(), 0), Info, Deduced, SubTDF);

 static QualType GetTypeOfFunction(Sema &S, const OverloadExpr::FindResult &R,
                                   FunctionDecl *Fn,
                                   ArrayRef<TemplateArgument> 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 = Args.size() != 0
+                    ? S.resugar(CXXScopeSpec(), Fn, Args, Fn->getType())
+                    : Fn->getType();
+
   if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn))
     if (Method->isInstance()) {
       // An instance method that's referenced in a form that doesn't
       // look like a member pointer is just invalid.
       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.
 ///
 /// \return the null type if this argument should be treated as an
 /// undeduced context
 static QualType
 ResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams,
SmallVector<DeducedTemplateArgument, 8>
       Deduced(TemplateParams->size());
     TemplateDeductionInfo Info(Ovl->getNameLoc());
     Sema::TemplateDeductionResult Result
       = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType,
                                            ArgType, Info, Deduced, TDF);
     if (Result) continue;
     if (!Match.isNull())
       return {};
+    // FIXME: resugar
     Match = ArgType;
   }
 
   return Match;
 }
 
 /// Perform the adjustments to the parameter and argument types
 /// described in C++ [temp.deduct.call].

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

while (!DC->isFileContext()) {
                                         TD->getTemplateParameters()->size())) {
             ArrayRef<TemplateArgument> Unpacked(Arg);
             if (Arg.getKind() == TemplateArgument::Pack)
               Unpacked = Arg.pack_elements();
             for (TemplateArgument UnpackedArg : Unpacked)
               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();
           assert(SubstRecord && "class template id not a class type?");
           // Check that this template-id names the primary template and not a
           // partial or explicit specialization. (In the latter cases, it's
           // meaningless to attempt to find an instantiation of D within the
           // specialization.)

clang/lib/Sema/SemaType.cpp

QualType Sema::BuildMemberPointerType(QualType T, QualType Class,
   }
 
   // Adjust the default free function calling convention to the default method
   // calling convention.
   bool IsCtorOrDtor =
       (Entity.getNameKind() == DeclarationName::CXXConstructorName) ||
       (Entity.getNameKind() == DeclarationName::CXXDestructorName);
   if (T->isFunctionType())
-    adjustMemberFunctionCC(T, /*IsStatic=*/false, IsCtorOrDtor, Loc);
+    adjustMemberFunctionCC(T, /*IsStatic=*/false, /*isDeduced=*/false,
+                           IsCtorOrDtor, Loc);
 
   return Context.getMemberPointerType(T, Class.getTypePtr());
 }
 
 /// Build a block pointer type.
 ///
 /// \param T The type to which we'll be building a block pointer.
 ///
while ((AT = T->getAs<AttributedType>()) &&
     if (AT->isCallingConv())
       return true;
     T = AT->getModifiedType();
   }
   return false;
 }
 
 void Sema::adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor,
-                                  SourceLocation Loc) {
+                                  bool isDeduced, SourceLocation Loc) {
   FunctionTypeUnwrapper Unwrapped(*this, T);
   const FunctionType *FT = Unwrapped.get();
   bool IsVariadic = (isa<FunctionProtoType>(FT) &&
                      cast<FunctionProtoType>(FT)->isVariadic());
   CallingConv CurCC = FT->getCallConv();
   CallingConv ToCC = Context.getDefaultCallingConvention(IsVariadic, !IsStatic);
 
   if (CurCC == ToCC)
// Default adjustment.
     // we should adjust a __cdecl type to __thiscall for instance methods, and a
     // __thiscall type to __cdecl for static methods.
     CallingConv DefaultCC =
         Context.getDefaultCallingConvention(IsVariadic, IsStatic);
 
     if (CurCC != DefaultCC || DefaultCC == ToCC)
       return;
 
-    if (hasExplicitCallingConv(T))
+    if (!isDeduced && hasExplicitCallingConv(T))
       return;
   }
 
   FT = Context.adjustFunctionType(FT, FT->getExtInfo().withCallingConv(ToCC));
   QualType Wrapped = Unwrapped.wrap(*this, FT);
   T = Context.getAdjustedType(T, Wrapped);
 }
 

clang/lib/Sema/TreeTransform.h

return SemaRef.Context.getDeducedTemplateSpecializationType(
         Template, Deduced, /*IsDependent*/ false);
   }
 
   /// Build a new template specialization type.
   ///
   /// 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);
 
   /// Build a new parenthesized type.
   ///
   /// By default, builds a new ParenType type from the inner type.
   /// Subclasses may override this routine to provide different behavior.
   QualType RebuildParenType(QualType InnerType) {
QualType RebuildDependentTemplateSpecializationType(
     // If it's still dependent, make a dependent specialization.
     if (InstName.getAsDependentTemplateName())
       return SemaRef.Context.getDependentTemplateSpecializationType(
           Keyword, QualifierLoc.getNestedNameSpecifier(), Name,
           Args.arguments());
 
     // 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(
         Keyword, QualifierLoc.getNestedNameSpecifier(), T);
   }
 
   /// Build a new typename type that refers to an identifier.
   ///
ExprResult RebuildMemberExpr(Expr *Base, SourceLocation OpLoc,
                                SourceLocation TemplateKWLoc,
                                const DeclarationNameInfo &MemberNameInfo,
                                ValueDecl *Member,
                                NamedDecl *FoundDecl,
                         const TemplateArgumentListInfo *ExplicitTemplateArgs,
                                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
       // field is always of record type.
       assert(Member->getType()->isRecordType() &&
              "unnamed member not of record type?");
 
       BaseResult =
         getSema().PerformObjectMemberConversion(BaseResult.get(),
                                                 QualifierLoc.getNestedNameSpecifier(),
                                                 FoundDecl, Member);
       if (BaseResult.isInvalid())
         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();
 
     if (isArrow && !BaseType->isPointerType())
       return ExprError();
 
     // FIXME: this involves duplicating earlier analysis in a lot of
     // cases; we should avoid this when possible.

 TreeTransform<Derived>::TransformTypeInObjectScope(TypeLoc TL,
                                                    QualType ObjectType,
                                                    NamedDecl *UnqualLookup,
                                                    CXXScopeSpec &SS) {
   if (getDerived().AlreadyTransformed(TL.getType()))
     return TL;
 
   TypeSourceInfo *TSI =
-      TransformTSIInObjectScope(TL, ObjectType, UnqualLookup, SS);
+      getDerived().TransformTSIInObjectScope(TL, ObjectType, UnqualLookup, SS);
   if (TSI)
     return TSI->getTypeLoc();
   return TypeLoc();
 }
 
 template<typename Derived>
 TypeSourceInfo *
 TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
                                                    QualType ObjectType,
                                                    NamedDecl *UnqualLookup,
                                                    CXXScopeSpec &SS) {
   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>
 TypeSourceInfo *TreeTransform<Derived>::TransformTSIInObjectScope(
     TypeLoc TL, QualType ObjectType, NamedDecl *UnqualLookup,
     CXXScopeSpec &SS) {
   QualType T = TL.getType();
   assert(!getDerived().AlreadyTransformed(T));
QualType TreeTransform<Derived>::TransformDependentSizedMatrixType(
   return Result;
 }
 
 template <typename Derived>
 QualType TreeTransform<Derived>::TransformDependentAddressSpaceType(
     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();
 
   // Address spaces are constant expressions.
   EnterExpressionEvaluationContext Unevaluated(
       SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
 
if (isa<DependentAddressSpaceType>(Result)) {
     DependentAddressSpaceTypeLoc NewTL =
         TLB.push<DependentAddressSpaceTypeLoc>(Result);
 
     NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
     NewTL.setAttrExprOperand(TL.getAttrExprOperand());
     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;
 }
 
 template <typename Derived>
 QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,
                                                      VectorTypeLoc TL) {
if (T->isCanonicalUnqualified()) {
     if (getDerived().TransformTemplateArguments(
             ArgIterator(TL, 0), ArgIterator(TL, TL.getNumArgs()),
             NewTemplateArgs))
       return QualType();
   }
 
   // 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
     // TemplateSpecializationTypes, and substitution of type alias templates
     // within a dependent context can transform them into
     // DependentTemplateSpecializationTypes.
     if (isa<DependentTemplateSpecializationType>(Result)) {
       DependentTemplateSpecializationTypeLoc NewTL
if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
     NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
     NewTL.setLAngleLoc(TL.getLAngleLoc());
     NewTL.setRAngleLoc(TL.getRAngleLoc());
     for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
       NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
     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?
     TemplateSpecializationTypeLoc NewTL
       = TLB.push<TemplateSpecializationTypeLoc>(Result);
     NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
     NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
     NewTL.setLAngleLoc(TL.getLAngleLoc());
TreeTransform<Derived>::TransformCallExpr(CallExpr *E) {
   Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
   if (E->hasStoredFPFeatures()) {
     FPOptionsOverride NewOverrides = E->getFPFeatures();
     getSema().CurFPFeatures =
         NewOverrides.applyOverrides(getSema().getLangOpts());
     getSema().FpPragmaStack.CurrentValue = NewOverrides;
   }
 
-  return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
-                                      Args,
+  return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc, Args,
                                       E->getRParenLoc());
 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) {
   ExprResult Base = getDerived().TransformExpr(E->getBase());
   if (Base.isInvalid())

 
 template<typename Derived>
 QualType TreeTransform<Derived>::RebuildUnaryTransformType(QualType BaseType,
                                             UnaryTransformType::UTTKind UKind,
                                             SourceLocation Loc) {
   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>
 QualType TreeTransform<Derived>::RebuildAtomicType(QualType ValueType,
                                                    SourceLocation KWLoc) {
   return SemaRef.BuildAtomicType(ValueType, KWLoc);
 }
 

clang/lib/StaticAnalyzer/Checkers/PointerSortingChecker.cpp

auto SortFuncM = anyOf(
                      callsName("std::partial_sort"),
                      callsName("std::partition"),
                      callsName("std::sort"),
                      callsName("std::stable_partition"),
                      callsName("std::stable_sort")
                     );
 
   // 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,
       stmt(callExpr(allOf(SortFuncM, IteratesPointerEltsM))).bind(WarnAtNode));
 
   return decl(forEachDescendant(PointerSortM));
 }
 

clang/test/Analysis/cast-value-notes.cpp

 using namespace llvm;
 using namespace clang;
 
 void clang_analyzer_printState();
 
 #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();
   // XX86-CHECK:      "dynamic_types": [
   // XX86-CHECK-NEXT:   { "region": "SymRegion{reg_$0<const struct clang::Shape & S>}", "dyn_type": "const class clang::Circle &", "sub_classable": true }
   (void)C;
 }
 #if defined(SUPPRESSED)
 void evalReferences_addrspace(const Shape &S) {
   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}}
 }
 #if defined(MIPS_SUPPRESSED)
 void evalReferences_addrspace(const Shape &S) {
   const auto &C = dyn_cast<DEVICE Circle>(S);
   (void)C;
 }
 #endif
 #endif
 
 void evalNonNullParamNonNullReturnReference(const Shape &S) {
   const auto *C = dyn_cast_or_null<Circle>(S);
   // 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;
   }
 
   if (isa<Triangle>(C)) {
     // expected-note@-1 {{'C' is not a 'Triangle'}}
     // expected-note@-2 {{Taking false branch}}
     return;
if (isa<Circle, Rectangle, Hexagon>(C)) {
     // expected-note@-1 {{'C' is non-null}}
     // expected-note@-2 {{Division by zero}}
     // expected-warning@-3 {{Division by zero}}
   }
 }
 
 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;
   }
 
   if (isa<Triangle>(C)) {
     // expected-note@-1 {{'C' is not a 'Triangle'}}
     // expected-note@-2 {{Taking false branch}}
     return;
if (isa<Circle, Rectangle, Hexagon>(C)) {
     // expected-note@-1 {{'C' is non-null}}
     // expected-note@-2 {{Division by zero}}
     // expected-warning@-3 {{Division by zero}}
   }
 }
 
 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}}
 
     (void)(1 / !T);
     // expected-note@-1 {{'T' is non-null}}
     // expected-note@-2 {{Division by zero}}
     // expected-warning@-3 {{Division by zero}}
   }
 }
 
 void evalNullParamNullReturn(const Shape *S) {
   const auto *C = dyn_cast_or_null<Circle>(S);
   // expected-note@-1 {{Assuming null pointer is passed into cast}}
   // expected-note@-2 {{'C' initialized to a null pointer value}}
 
   (void)(1 / (bool)C);
   // expected-note@-1 {{Division by zero}}
   // expected-warning@-2 {{Division by zero}}
 }
 
 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);
   // expected-note@-1 {{'C' is non-null}}
   // expected-note@-2 {{Division by zero}}
   // expected-warning@-3 {{Division by zero}}
 }
 
 void evalZeroParamNonNullReturn(const Shape &S) {
   const auto *C = S.castAs<Circle>();
   // expected-note@-1 {{'C' initialized here}}
 
   (void)(1 / !C);
   // expected-note@-1 {{'C' is non-null}}
   // expected-note@-2 {{Division by zero}}
   // expected-warning@-3 {{Division by zero}}
 }
 
 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;
   }
 
   if (!dyn_cast_or_null<Triangle>(S)) {
     // expected-note@-1 {{'S' is a 'Triangle'}}
     // expected-note@-2 {{Taking false branch}}
     return;

clang/test/Analysis/cast-value-state-dump.cpp

 class Square : public Shape {};
 } // namespace clang
 
 using namespace llvm;
 using namespace clang;
 
 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;
   }
 
   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": [
   // CHECK-NEXT:     { "from": "struct clang::Shape", "to": "class clang::Circle", "kind": "success" },
   // CHECK-NEXT:     { "from": "struct clang::Shape", "to": "class clang::Square", "kind": "fail" }
   // CHECK-NEXT:   ] }
 
   (void)(1 / !C);
   // expected-note@-1 {{'C' is non-null}}
   // expected-note@-2 {{Division by zero}}
   // expected-warning@-3 {{Division by zero}}
 }
 

clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.elab/p3.cpp

 template <> struct B<A> {
   union Member { // expected-note 4 {{previous use is here}}
     void* a;
   };
 };
 
 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);
 void c3(union B<float>::Member); // expected-error {{use of 'Member' with tag type that does not match previous declaration}}
 void c4(enum B<float>::Member); // expected-error {{use of 'Member' with tag type that does not match previous declaration}}
 
 void d1(struct B<int>::Member); // expected-error {{no struct named 'Member' in 'B<int>'}}
 void d2(class B<int>::Member); // expected-error {{no class named 'Member' in 'B<int>'}}

clang/test/CodeGenCXX/mangle-ms-back-references-pr13207.cpp

-// 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 {};
 template<class X>
 class B {};
 template<class X>
 class C {};
 

 
 
 template <class T1, class T2, class T3, class T4, class T5, class T6, class T7,
           class T8, class T9, class T10, class T11, class T12, class T13,
           class T14, class T15, class T16, class T17, class T18, class T19,
           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>;
 using B3 = Food<B2, B1, B0, B0, B0, B0, B0, B0, B0, B0,  B2, B2, B2, B2, B2, B2, B2, B2, B2, B2>;
 using B4 = Food<B3, B2, B1, B0, B0, B0, B0, B0, B0, B0,  B3, B3, B3, B3, B3, B3, B3, B3, B3, B3>;
 using B5 = Food<B4, B3, B2, B1, B0, B0, B0, B0, B0, B0,  B4, B4, B4, B4, B4, B4, B4, B4, B4, B4>;
 using B6 = Food<B5, B4, B3, B2, B1, B0, B0, B0, B0, B0,  B5, B5, B5, B5, B5, B5, B5, B5, B5, B5>;
 

clang/test/CodeGenCXX/pr29160.cpp

-// 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>
   static void ignore() {}
   Foo() { ignore<Ts...>(); }
 };
 
 struct Base {

clang/test/Misc/diag-template-diffing.cpp

 Wrapper<S<&global2, static_cast<int *>(0)>> W11 =
     MakeWrapper<S<&global, nullptr>>();
 // CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<&global, [...]>>' to 'Wrapper<S<&global2, [...]>>'
 Wrapper<S<&global2, nullptr>> W12 =
     MakeWrapper<S<&global, static_cast<int *>(0)>>();
 // 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>>'
 }
 
 namespace TemplateTemplateDefault {
 template <class> class A{};
 template <class> class B{};
 template <class> class C{};

 }
 
 namespace DefaultNonTypeArgWithDependentType {
 // We used to crash diffing integer template arguments when the argument type
 // is dependent and default arguments were used.
 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 {
 template <typename T, T v>
 struct integral_constant {};
 
 auto false_ = integral_constant<bool, false> {};
 

clang/test/Sema/Resugar/resugar-expr.cpp

+// 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

clang/test/Sema/Resugar/resugar-types.cpp

+// 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(A<Bar>::type1);
+} // 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(typename T1::type2);
+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

clang/test/SemaTemplate/attributes.cpp

template<typename T> struct MemberTemplate {
     using iterator = Iter<T>;
     using const_iterator = Iter<const T>;
     template<typename U>
     struct [[clang::preferred_name(iterator),
              clang::preferred_name(const_iterator)]] Iter {};
   };
   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...>;
   template<int A, int B, typename ...T> struct [[clang::preferred_name(::preferred_name::Bar<T...>)]] Foo {};
   Foo<1, 2, int, float>::nosuch x; // expected-error {{no type named 'nosuch' in 'preferred_name::Bar<int, float>'}}
 }
 ::preferred_name::Foo<1, 2, int, float>::nosuch x; // expected-error {{no type named 'nosuch' in 'preferred_name::Bar<int, float>'}}

clang/test/SemaTemplate/deduction-guide.cpp

 using DT = decltype(d);
 using DT = D<int, int>;
 
 // CHECK-LABEL: Dumping <deduction guide for D>:
 // CHECK: FunctionTemplateDecl
 // 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
 // CHECK: `-PointerType {{.*}} 'B<type-parameter-0-1, type-parameter-0-2> *' dependent
 // CHECK:   `-TemplateSpecializationType {{.*}} 'B<type-parameter-0-1, type-parameter-0-2>' sugar dependent alias B
 // CHECK:     |-TemplateArgument type 'type-parameter-0-1'
 // CHECK:     |-TemplateArgument type 'type-parameter-0-2'
 // CHECK:     `-FunctionProtoType {{.*}} 'int (int (*)(T, U)...)' dependent cdecl

clang/test/SemaTemplate/make_integer_seq.cpp

 // CHECK-NEXT:           `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} 'A<int, 0>' sugar A
 // CHECK-NEXT:             |-TemplateArgument type 'int':'int'
 // CHECK-NEXT:             | `-SubstTemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'int' sugar typename depth 0 index 1
 // CHECK-NEXT:             |   |-BuiltinTemplate 0x{{[0-9A-Fa-f]+}} '__make_integer_seq'
 // CHECK-NEXT:             |   `-SubstTemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'int' sugar class depth 0 index 0 B1
 // 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>'
 // CHECK-NEXT:               `-ClassTemplateSpecialization 0x{{[0-9A-Fa-f]+}} 'A'
 
 template <template <class T, T...> class S, class T, int N> struct C {
   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:       |-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> 'T':'T' <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> 'T':'T' <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> 'T':'T' <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:       |-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> 'T':'T' <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> 'T':'T' <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> 'T':'T' <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:       |-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:     `-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'
 };
 
 // expected-no-diagnostics
 
 template <class T, class S> struct D;
 template <class T> struct D<T, __make_integer_seq<A, int, sizeof(T)>> {};
 template struct D<char, A<int, 0>>;
 

clang/test/SemaTemplate/type_pack_element.cpp

 // CHECK-NEXT:       `-SubstTemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'int' sugar typename depth 0 index 1 ... pack_index 0
 // CHECK-NEXT:         |-BuiltinTemplate 0x{{[0-9A-Fa-f]+}} '__type_pack_element'
 // CHECK-NEXT:         `-BuiltinType 0x{{[0-9A-Fa-f]+}} 'int'
 
 template<int N, class ...Ts> struct A {
   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:       |-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:     `-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'
 
   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:       |-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:     `-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'
 
   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:       |-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:     `-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'
 };
 
 // expected-no-diagnostics
 
 template <class T, class S> struct B;
 template <class T> struct B<T, __type_pack_element<sizeof(T), void, long>> {};
 template struct B<char, long>;
 

clang/unittests/Tooling/StencilTest.cpp

TEST_F(StencilTest, DescribeUnqualifiedType) {
   auto StmtMatch =
       matchStmt(Snippet, declRefExpr(hasType(qualType().bind("type"))));
   ASSERT_TRUE(StmtMatch);
   EXPECT_THAT_EXPECTED(describe("type")->eval(StmtMatch->Result),
                        HasValue(std::string(Expected)));
 }
 
 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);
   EXPECT_THAT_EXPECTED(describe("type")->eval(StmtMatch->Result),
                        HasValue(std::string(Expected)));
 }
 
 TEST_F(StencilTest, RunOp) {

libcxx/DELETE.ME

 D131858
 D134604
 D134113
+D127695