[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

244 ↗

(On Diff #449993)

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

244 ↗

(On Diff #449993)

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

533–539

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

533–539

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

533–539

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

881–884

Move back down?

1001–1007

Move back up?

clang/lib/Sema/SemaExpr.cpp

3427–3430 ↗

(On Diff #464192)

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

20800 ↗

(On Diff #464192)

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

clang/lib/Sema/SemaExprMember.cpp

1862 ↗

(On Diff #464192)

Rename to FieldQuals

clang/lib/Sema/SemaOverload.cpp

15357 ↗

(On Diff #464192)

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

94

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.)

129

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

160

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

256

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

264

Could clarify to CXXRecordDecl

292

Add message

465

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

478

AssociatedDecl

742

Add message

4345–4347

Change back to original?

4956–4971

Move back up?

clang/lib/Sema/TreeTransform.h

2679–2681 ↗

(On Diff #464192)

Move back down?

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

244 ↗

(On Diff #449993)

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

94

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/ASTContext.h

#include "clang/Basic/RISCVVTypes.def"
   //===--------------------------------------------------------------------===//
 
 private:
   /// Return a type with extended qualifiers.
   QualType getExtQualType(const Type *Base, Qualifiers Quals) const;
 
   QualType getTypeDeclTypeSlow(const TypeDecl *Decl) const;
 
-  QualType getPipeType(QualType T, bool ReadOnly) const;
-
 public:
   /// Return the uniqued reference to the type for an address space
   /// qualified type with the specified type and address space.
   ///
   /// The resulting type has a union of the qualifiers from T and the address
   /// space. If T already has an address space specifier, it is silently
   /// replaced.
   QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const;
public:
   /// Return the uniqued reference to the type for a block of the
   /// specified type.
   QualType getBlockPointerType(QualType T) const;
 
   /// Gets the struct used to keep track of the descriptor for pointer to
   /// blocks.
   QualType getBlockDescriptorType() const;
 
+  // Return a pipe type for the specified type.
+  QualType getPipeType(QualType T, bool ReadOnly) const;
+
   /// Return a read_only pipe type for the specified type.
   QualType getReadPipeType(QualType T) const;
 
   /// Return a write_only pipe type for the specified type.
   QualType getWritePipeType(QualType T) const;
 
   /// Return a bit-precise integer type with the specified signedness and bit
   /// count.

clang/include/clang/AST/Type.h

public:
   /// Return true if the set contains any qualifiers.
   bool hasQualifiers() const { return Mask; }
   bool empty() const { return !Mask; }
 
   /// Add the qualifiers from the given set to this set.
   void addQualifiers(Qualifiers Q) {
     // If the other set doesn't have any non-boolean qualifiers, just
     // bit-or it in.
-    if (!(Q.Mask & ~CVRMask))
+    if (!(Q.Mask & ~CVRUMask))
       Mask |= Q.Mask;
     else {
-      Mask |= (Q.Mask & CVRMask);
+      Mask |= (Q.Mask & CVRUMask);
       if (Q.hasAddressSpace())
         addAddressSpace(Q.getAddressSpace());
       if (Q.hasObjCGCAttr())
         addObjCGCAttr(Q.getObjCGCAttr());
       if (Q.hasObjCLifetime())
         addObjCLifetime(Q.getObjCLifetime());
     }
   }
 
   /// Remove the qualifiers from the given set from this set.
   void removeQualifiers(Qualifiers Q) {
     // If the other set doesn't have any non-boolean qualifiers, just
     // bit-and the inverse in.
-    if (!(Q.Mask & ~CVRMask))
+    if (!(Q.Mask & ~CVRUMask))
       Mask &= ~Q.Mask;
     else {
-      Mask &= ~(Q.Mask & CVRMask);
+      Mask &= ~(Q.Mask & CVRUMask);
       if (getObjCGCAttr() == Q.getObjCGCAttr())
         removeObjCGCAttr();
       if (getObjCLifetime() == Q.getObjCLifetime())
         removeObjCLifetime();
       if (getAddressSpace() == Q.getAddressSpace())
         removeAddressSpace();
     }
   }

 
 private:
   // bits:     |0 1 2|3|4 .. 5|6  ..  8|9   ...   31|
   //           |C R V|U|GCAttr|Lifetime|AddressSpace|
   uint32_t Mask = 0;
 
   static const uint32_t UMask = 0x8;
   static const uint32_t UShift = 3;
+  static const uint32_t CVRUMask = CVRMask | UMask;
   static const uint32_t GCAttrMask = 0x30;
   static const uint32_t GCAttrShift = 4;
   static const uint32_t LifetimeMask = 0x1C0;
   static const uint32_t LifetimeShift = 6;
   static const uint32_t AddressSpaceMask =
       ~(CVRMask | UMask | GCAttrMask | LifetimeMask);
   static const uint32_t AddressSpaceShift = 9;
 };

clang/include/clang/Sema/Sema.h

public:
 
   DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType = nullptr);
 
   void DiagnoseUseOfUnimplementedSelectors();
 
   bool isSimpleTypeSpecifier(tok::TokenKind Kind) const;
 
   enum class DiagCtorKind { None, Implicit, Typename };
-  QualType getTypeDeclType(DeclContext *LookupCtx, DiagCtorKind DCK,
+  QualType getTypeDeclType(const NestedNameSpecifier *NNS,
+                           DeclContext *LookupCtx, DiagCtorKind DCK,
                            TypeDecl *TD, SourceLocation NameLoc);
 
   ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
                          Scope *S, CXXScopeSpec *SS = nullptr,
                          bool isClassName = false, bool HasTrailingDot = false,
                          ParsedType ObjectType = nullptr,
                          bool IsCtorOrDtorName = false,
                          bool WantNontrivialTypeSourceInfo = false,
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:
     const FunctionProtoType::ExtParameterInfo *
     getPointerOrNull(unsigned numParams) {
       if (!HasInteresting) return nullptr;
       Infos.resize(numParams);
       return Infos.data();
     }
   };
 
+  QualType resugar(const NestedNameSpecifier *NNS, 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

case Type::PackExpansion: {
     assert(PX->getNumExpansions() == PY->getNumExpansions());
     return Ctx.getPackExpansionType(
         Ctx.getCommonSugaredType(PX->getPattern(), PY->getPattern()),
         PX->getNumExpansions(), false);
   }
   case Type::Pipe: {
     const auto *PX = cast<PipeType>(X), *PY = cast<PipeType>(Y);
     assert(PX->isReadOnly() == PY->isReadOnly());
-    auto MP = PX->isReadOnly() ? &ASTContext::getReadPipeType
-                               : &ASTContext::getWritePipeType;
-    return (Ctx.*MP)(getCommonElementType(Ctx, PX, PY));
+    return Ctx.getPipeType(getCommonElementType(Ctx, PX, PY), PX->isReadOnly());
   }
   case Type::TemplateTypeParm: {
     const auto *TX = cast<TemplateTypeParmType>(X),
                *TY = cast<TemplateTypeParmType>(Y);
     assert(TX->getDepth() == TY->getDepth());
     assert(TX->getIndex() == TY->getIndex());
     assert(TX->isParameterPack() == TY->isParameterPack());
     return Ctx.getTemplateTypeParmType(

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.getScopeRep(),
+        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,
 
   assert(DS.getTypeSpecType() == DeclSpec::TST_decltype);
 
   QualType T = BuildDecltypeType(DS.getRepAsExpr());
   if (T.isNull())
     return true;
 
   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;
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());
 
 
   SS.Extend(Context, TemplateKWLoc, Builder.getTypeLocInContext(Context, T),
             CCLoc);
   return false;
 }
 
 namespace {
   /// A structure that stores a nested-name-specifier annotation,
   /// including both the nested-name-specifier
   struct NestedNameSpecifierAnnotation {
     NestedNameSpecifier *NNS;
   };
 }
 
 void *Sema::SaveNestedNameSpecifierAnnotation(CXXScopeSpec &SS) {

clang/lib/Sema/SemaCoroutine.cpp

static QualType lookupPromiseType(Sema &S, const FunctionDecl *FD,
   if (!Promise) {
     S.Diag(FuncLoc,
            diag::err_implied_std_coroutine_traits_promise_type_not_found)
         << RD;
     return QualType();
   }
   // The promise type is required to be a class type.
   QualType PromiseType = S.Context.getTypeDeclType(Promise);
+  // FIXME: resugar PromiseType.
 
   auto buildElaboratedType = [&]() {
     auto *NNS = NestedNameSpecifier::Create(S.Context, nullptr, CoroNamespace);
     NNS = NestedNameSpecifier::Create(S.Context, NNS, false,
                                       CoroTrait.getTypePtr());
     return S.Context.getElaboratedType(ETK_None, NNS, PromiseType);
   };
 

clang/lib/Sema/SemaDecl.cpp

#include "clang/Basic/TransformTypeTraits.def"
 
   default:
     break;
   }
 
   return false;
 }
 
-QualType Sema::getTypeDeclType(DeclContext *LookupCtx, DiagCtorKind DCK,
+QualType Sema::getTypeDeclType(const NestedNameSpecifier *NNS,
+                               DeclContext *LookupCtx, DiagCtorKind DCK,
                                TypeDecl *TD, SourceLocation NameLoc) {
   auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
   auto *FoundRD = dyn_cast<CXXRecordDecl>(TD);
   if (DCK != DiagCtorKind::None && LookupRD && FoundRD &&
       FoundRD->isInjectedClassName() &&
       declaresSameEntity(LookupRD, cast<Decl>(FoundRD->getParent()))) {
     Diag(NameLoc,
          DCK == DiagCtorKind::Typename
              ? diag::ext_out_of_line_qualified_id_type_names_constructor
              : diag::err_out_of_line_qualified_id_type_names_constructor)
         << TD->getIdentifier() << /*Type*/ 1
         << 0 /*if any keyword was present, it was 'typename'*/;
   }
 
   DiagnoseUseOfDecl(TD, NameLoc);
   MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false);
-  return Context.getTypeDeclType(TD);
+  return resugar(NNS, Context.getTypeDeclType(TD));
 }
 
 namespace {
 enum class UnqualifiedTypeNameLookupResult {
   NotFound,
   FoundNonType,
   FoundType
 };
ParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
 
   assert(IIDecl && "Didn't find decl");
 
   QualType T;
   if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
     // C++ [class.qual]p2: A lookup that would find the injected-class-name
     // instead names the constructors of the class, except when naming a class.
     // This is ill-formed when we're not actually forming a ctor or dtor name.
-    T = getTypeDeclType(LookupCtx,
+    T = getTypeDeclType(SS ? SS->getScopeRep() : nullptr, LookupCtx,
                         IsImplicitTypename ? DiagCtorKind::Implicit
                                            : DiagCtorKind::None,
                         TD, NameLoc);
   } 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.
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;

clang/lib/Sema/SemaDeclCXX.cpp

if (!TD) {
     R.suppressDiagnostics();
     S.Diag(Loc, diag::err_decomp_decl_std_tuple_element_not_specialized)
         << printTemplateArgs(S.Context.getPrintingPolicy(), Args,
                              /*Params*/ nullptr);
     if (!R.empty())
       S.Diag(R.getRepresentativeDecl()->getLocation(), diag::note_declared_at);
     return QualType();
   }
-
+  // FIXME: resugar
   return S.Context.getTypeDeclType(TD);
 }
 
 namespace {
 struct InitializingBinding {
   Sema &S;
   InitializingBinding(Sema &S, BindingDecl *BD) : S(S) {
     Sema::CodeSynthesisContext Ctx;

clang/lib/Sema/SemaTemplate.cpp

if (!Info.TemplateParams.empty()) {
       ParamsAtDepth(Info.AutoTemplateParameterDepth);
       break;
     }
   }
 
   return Depth;
 }
 
+namespace {
+
+class NameMap {
+  llvm::DenseMap<const Decl *, ArrayRef<TemplateArgument>> Map;
+
+  void insert(const Decl *AssociatedDecl, ArrayRef<TemplateArgument> Args) {
+    assert(!Args.empty());
+    Map.try_emplace(AssociatedDecl->getCanonicalDecl(), Args);
+  }
+
+public:
+  NameMap() = default;
+
+  const TemplateArgument *getArgument(const Decl *AssociatedDecl,
+                                      unsigned Index,
+                                      Optional<unsigned> PackIndex) const {
+    auto It = Map.find(AssociatedDecl);
+    if (It == Map.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];
+  }
+
+  void insert(Sema &SemaRef, const Type *T) {
+    const Type *CanonT = T->getCanonicalTypeInternal().getTypePtr();
+    if (auto TC = CanonT->getTypeClass(); TC != Type::Record) {
+      assert(TC == Type::Enum || TC == Type::InjectedClassName ||
+             T->isDependentType());
+      return;
+    }
+    const auto *TS = T->getAsNonAliasTemplateSpecializationType();
+    if (!TS)
+      return;
+    auto *CTSD = cast<ClassTemplateSpecializationDecl>(
+        cast<RecordType>(CanonT)->getDecl());
+    auto PU = CTSD->getInstantiatedFrom();
+    if (PU.isNull())
+      return;
+
+    ArrayRef<TemplateArgument> Args = TS->getConvertedArguments();
+    auto *CTPSD = PU.dyn_cast<ClassTemplatePartialSpecializationDecl *>();
+    if (!CTPSD)
+      return insert(CTSD, Args);
+    // FIXME: Don't deduce partial specialization args on resugaring.
+    TemplateParameterList *TPL = CTPSD->getTemplateParameters();
+    TemplateDeductionInfo Info(SourceLocation(), TPL->getDepth());
+    [[maybe_unused]] Sema::TemplateDeductionResult Res =
+        SemaRef.DeduceTemplateArguments(
+            CTPSD,
+            TemplateArgumentList(TemplateArgumentList::OnStackType{}, Args),
+            Info);
+    assert(Res == Sema::TDK_Success);
+    insert(CTSD, Info.takeSugared()->asArray());
+  }
+
+  void insert(Sema &SemaRef, const NestedNameSpecifier *NNS) {
+    for (/**/; NNS; NNS = NNS->getPrefix()) {
+      switch (NNS->getKind()) {
+      case NestedNameSpecifier::Global:
+      case NestedNameSpecifier::Namespace:
+      case NestedNameSpecifier::NamespaceAlias:
+      case NestedNameSpecifier::Super:
+        return;
+      case NestedNameSpecifier::Identifier:
+        continue;
+      case NestedNameSpecifier::TypeSpec:
+      case NestedNameSpecifier::TypeSpecWithTemplate:
+        insert(SemaRef, NNS->getAsType());
+        continue;
+      }
+      llvm_unreachable("Unknown NestedNameSpecifier Kind");
+    }
+  }
+
+  bool empty() const { return Map.empty(); }
+};
+
+class Resugarer {
+  Sema &SemaRef;
+  const NameMap *Names;
+  llvm::DenseMap<QualType, QualType> CacheTypes;
+
+public:
+  Resugarer(Sema &SemaRef, const NameMap &Names)
+      : SemaRef(SemaRef), Names(&Names) {}
+
+  template <class T>
+  SmallVector<T, 4> transform(ArrayRef<T> Es, bool &Changed) {
+    SmallVector<T, 4> TransformedEs(Es);
+    for (auto &E : TransformedEs)
+      E = transform(E, Changed);
+    return TransformedEs;
+  }
+
+  NestedNameSpecifier *transform(NestedNameSpecifier *NNS, bool &OutChanged) {
+    if (!NNS)
+      return NNS;
+
+    bool Changed = false;
+    switch (auto K = NNS->getKind()) {
+    case NestedNameSpecifier::Global:
+    case NestedNameSpecifier::Namespace:
+    case NestedNameSpecifier::NamespaceAlias:
+    case NestedNameSpecifier::Super:
+      return NNS;
+    case NestedNameSpecifier::Identifier: {
+      NestedNameSpecifier *Prefix = transform(NNS->getPrefix(), Changed);
+      if (!Changed)
+        return NNS;
+      OutChanged = true;
+      return NestedNameSpecifier::Create(SemaRef.Context, Prefix,
+                                         NNS->getAsIdentifier());
+    }
+    case NestedNameSpecifier::TypeSpec:
+    case NestedNameSpecifier::TypeSpecWithTemplate: {
+      const Type *T =
+          transform(QualType(NNS->getAsType(), 0), Changed).getTypePtr();
+      NestedNameSpecifier *Prefix;
+      if (const auto *ET = dyn_cast<ElaboratedType>(T)) {
+        Prefix = transform(ET->getQualifier(), Changed);
+        T = ET->getNamedType().getTypePtr();
+      } else {
+        Prefix = transform(NNS->getPrefix(), Changed);
+      }
+      if (!Changed)
+        return NNS;
+      OutChanged = true;
+      return NestedNameSpecifier::Create(
+          SemaRef.Context, Prefix,
+          K == NestedNameSpecifier::TypeSpecWithTemplate, T);
+    }
+    }
+    llvm_unreachable("Unknown NestedNameSpecifier Kind");
+  }
+
+  TemplateName transform(TemplateName TN, bool &OutChanged) {
+    auto build = [&](TemplateName NewTN) {
+      assert(SemaRef.Context.hasSameTemplateName(TN, NewTN));
+      OutChanged = true;
+      return NewTN;
+    };
+
+    bool Changed = false;
+    switch (TN.getKind()) {
+    case TemplateName::AssumedTemplate:
+    case TemplateName::OverloadedTemplate:
+    case TemplateName::Template:
+    case TemplateName::UsingTemplate:
+      return TN;
+    case TemplateName::DependentTemplate: {
+      const auto *DTN = TN.getAsDependentTemplateName();
+      NestedNameSpecifier *NNS = transform(DTN->getQualifier(), Changed);
+      if (!Changed)
+        return TN;
+      return build(
+          SemaRef.Context.getDependentTemplateName(NNS, DTN->getOperator()));
+    }
+    case TemplateName::QualifiedTemplate: {
+      const auto *QTN = TN.getAsQualifiedTemplateName();
+      NestedNameSpecifier *NNS = transform(QTN->getQualifier(), Changed);
+      TemplateName UTN = transform(QTN->getUnderlyingTemplate(), Changed);
+      if (!Changed)
+        return TN;
+      return build(SemaRef.Context.getQualifiedTemplateName(
+          NNS, QTN->hasTemplateKeyword(), UTN));
+    }
+    case TemplateName::SubstTemplateTemplateParm: {
+      const auto *STN = TN.getAsSubstTemplateTemplateParm();
+      const TemplateArgument *Arg = Names->getArgument(
+          STN->getAssociatedDecl(), STN->getIndex(), STN->getPackIndex());
+      if (!Arg)
+        return TN;
+      return build(Arg->getAsTemplate());
+    }
+    case TemplateName::SubstTemplateTemplateParmPack: {
+      const auto *STNP = TN.getAsSubstTemplateTemplateParmPack();
+      TemplateArgument Pack = transform(STNP->getArgumentPack(), Changed);
+      if (!Changed)
+        return TN;
+      return build(SemaRef.Context.getSubstTemplateTemplateParmPack(
+          Pack, STNP->getAssociatedDecl(), STNP->getIndex(), STNP->getFinal()));
+    }
+    }
+    llvm_unreachable("Unhandled TemplateName kind");
+  }
+
+  QualType buildType(QualType Orig, const Type *Ty, Qualifiers Quals) {
+    QualType NewT = SemaRef.Context.getQualifiedType(Ty, Quals);
+    assert(SemaRef.Context.hasSameType(Orig, NewT));
+    CacheTypes.find(Orig)->second = NewT;
+    return NewT;
+  }
+
+  QualType transform(QualType TT, bool &OutChanged) {
+    if (TT.isNull() || TT.isCanonical())
+      return TT;
+
+    if (auto [It, Created] = CacheTypes.try_emplace(TT, TT); !Created) {
+      QualType NewT = It->second;
+      OutChanged |= (NewT != TT);
+      return NewT;
+    }
+
+    SplitQualType ST = TT.split();
+    auto build = [&](QualType T) {
+      OutChanged = true;
+      return buildType(TT, T.getTypePtr(), ST.Quals);
+    };
+
+    bool Changed = false;
+    switch (ST.Ty->getTypeClass()) {
+    case Type::Adjusted: {
+      const auto *T = cast<AdjustedType>(ST.Ty);
+      QualType OT = transform(T->getOriginalType(), Changed);
+      // FIXME: Handle AdjustedType.
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getAdjustedType(OT, T->getAdjustedType()));
+    }
+    case Type::Atomic: {
+      const auto *T = cast<AtomicType>(ST.Ty);
+      QualType VT = transform(T->getValueType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getAtomicType(VT));
+    }
+    case Type::Attributed: {
+      const auto *T = cast<AttributedType>(ST.Ty);
+      QualType MT = transform(T->getModifiedType(), Changed);
+      // FIXME: Handle EquivalentType.
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getAttributedType(T->getAttrKind(), MT,
+                                                     T->getEquivalentType()));
+    }
+    case Type::Auto: {
+      const auto *T = cast<AutoType>(ST.Ty);
+      auto Args = transform(T->getTypeConstraintArguments(), Changed);
+      QualType DT = transform(T->getDeducedType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(
+          SemaRef.Context.getAutoType(DT, T->getKeyword(), DT.isNull(),
+                                      T->containsUnexpandedParameterPack(),
+                                      T->getTypeConstraintConcept(), Args));
+    }
+    case Type::BitInt:
+      return TT;
+    case Type::BlockPointer: {
+      const auto *T = cast<BlockPointerType>(ST.Ty);
+      QualType PT = transform(T->getPointeeType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getBlockPointerType(PT));
+    }
+    case Type::Builtin:
+      return TT;
+    case Type::BTFTagAttributed: {
+      const auto *T = cast<BTFTagAttributedType>(ST.Ty);
+      QualType WT = transform(T->getWrappedType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getBTFTagAttributedType(T->getAttr(), WT));
+    }
+    case Type::Complex: {
+      const auto *T = cast<ComplexType>(ST.Ty);
+      QualType ET = transform(T->getElementType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getComplexType(ET));
+    }
+    case Type::ConstantArray: {
+      const auto *T = cast<ConstantArrayType>(ST.Ty);
+      QualType ET = transform(T->getElementType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getConstantArrayType(
+          ET, T->getSize(), T->getSizeExpr(), T->getSizeModifier(),
+          T->getIndexTypeCVRQualifiers()));
+    }
+    case Type::ConstantMatrix: {
+      const auto *T = cast<ConstantMatrixType>(ST.Ty);
+      QualType ET = transform(T->getElementType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getConstantMatrixType(ET, T->getNumRows(),
+                                                         T->getNumColumns()));
+    }
+    case Type::Decltype: {
+      const auto *T = cast<DecltypeType>(ST.Ty);
+      QualType UT = transform(T->getUnderlyingType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getDecltypeType(T->getUnderlyingExpr(), UT));
+    }
+    case Type::Decayed: {
+      const auto *T = cast<DecayedType>(ST.Ty);
+      QualType OT = transform(T->getOriginalType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getDecayedType(OT));
+    }
+    case Type::DeducedTemplateSpecialization: {
+      const auto *T = cast<DeducedTemplateSpecializationType>(ST.Ty);
+      TemplateName TN = transform(T->getTemplateName(), Changed);
+      QualType DT = transform(T->getDeducedType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getDeducedTemplateSpecializationType(
+          TN, DT, DT.isNull()));
+    }
+    case Type::DependentAddressSpace: {
+      const auto *T = cast<DependentAddressSpaceType>(ST.Ty);
+      QualType PT = transform(T->getPointeeType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getDependentAddressSpaceType(
+          PT, T->getAddrSpaceExpr(), T->getAttributeLoc()));
+    }
+    case Type::DependentBitInt:
+      return TT;
+    case Type::DependentName: {
+      const auto *T = cast<DependentNameType>(ST.Ty);
+      NestedNameSpecifier *NNS = transform(T->getQualifier(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getDependentNameType(T->getKeyword(), NNS,
+                                                        T->getIdentifier()));
+    }
+    case Type::DependentSizedArray: {
+      const auto *T = cast<DependentSizedArrayType>(ST.Ty);
+      QualType ET = transform(T->getElementType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getDependentSizedArrayType(
+          ET, T->getSizeExpr(), T->getSizeModifier(),
+          T->getIndexTypeCVRQualifiers(), T->getBracketsRange()));
+    }
+    case Type::DependentSizedExtVector: {
+      const auto *T = cast<DependentSizedExtVectorType>(ST.Ty);
+      QualType ET = transform(T->getElementType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getDependentSizedExtVectorType(
+          ET, T->getSizeExpr(), T->getAttributeLoc()));
+    }
+    case Type::DependentSizedMatrix: {
+      const auto *T = cast<DependentSizedMatrixType>(ST.Ty);
+      QualType ET = transform(T->getElementType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getDependentSizedMatrixType(
+          ET, T->getRowExpr(), T->getColumnExpr(), T->getAttributeLoc()));
+    }
+    case Type::DependentVector: {
+      const auto *T = cast<DependentVectorType>(ST.Ty);
+      QualType ET = transform(T->getElementType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getDependentVectorType(
+          ET, T->getSizeExpr(), T->getAttributeLoc(), T->getVectorKind()));
+    }
+    case Type::DependentTemplateSpecialization: {
+      const auto *T = cast<DependentTemplateSpecializationType>(ST.Ty);
+      auto SpecArgs = transform(T->template_arguments(), Changed);
+      NestedNameSpecifier *NNS = transform(T->getQualifier(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getDependentTemplateSpecializationType(
+          T->getKeyword(), NNS, T->getIdentifier(), SpecArgs));
+    }
+    case Type::Elaborated: {
+      const auto *T = cast<ElaboratedType>(ST.Ty);
+      NestedNameSpecifier *NNS = transform(T->getQualifier(), Changed);
+      QualType NT = transform(T->getNamedType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getElaboratedType(T->getKeyword(), NNS, NT,
+                                                     T->getOwnedTagDecl()));
+    }
+    case Type::Enum:
+      // FIXME: Resugar.
+      return TT;
+    case Type::ExtVector: {
+      const auto *T = cast<ExtVectorType>(ST.Ty);
+      QualType ET = transform(T->getElementType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getExtVectorType(ET, T->getNumElements()));
+    }
+    case Type::FunctionNoProto: {
+      const auto *T = cast<FunctionNoProtoType>(ST.Ty);
+      QualType RT = transform(T->getReturnType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getFunctionNoProtoType(RT, T->getExtInfo()));
+    }
+    case Type::FunctionProto: {
+      const auto *T = cast<FunctionProtoType>(ST.Ty);
+      FunctionProtoType::ExtProtoInfo EPI = T->getExtProtoInfo();
+      QualType RT = transform(T->getReturnType(), Changed);
+      auto Ps = transform(T->param_types(), Changed);
+      auto Es = transform(EPI.ExceptionSpec.Exceptions, Changed);
+      if (!Changed)
+        return TT;
+      EPI.ExceptionSpec.Exceptions = Es;
+      return build(SemaRef.Context.getFunctionType(RT, Ps, EPI));
+    }
+    case Type::IncompleteArray: {
+      const auto *T = cast<IncompleteArrayType>(ST.Ty);
+      QualType ET = transform(T->getElementType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getIncompleteArrayType(
+          ET, T->getSizeModifier(), T->getIndexTypeCVRQualifiers()));
+    }
+    case Type::InjectedClassName: {
+      const auto *T = cast<InjectedClassNameType>(ST.Ty);
+      QualType TST = transform(T->getInjectedSpecializationType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getInjectedClassNameType(T->getDecl(), TST));
+    }
+    case Type::LValueReference: {
+      const auto *T = cast<LValueReferenceType>(ST.Ty);
+      QualType PT = transform(T->getPointeeTypeAsWritten(), Changed);
+      if (!Changed)
+        return TT;
+      return build(
+          SemaRef.Context.getLValueReferenceType(PT, T->isSpelledAsLValue()));
+    }
+    case Type::MacroQualified: {
+      const auto *T = cast<MacroQualifiedType>(ST.Ty);
+      QualType UT = transform(T->getUnderlyingType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(
+          SemaRef.Context.getMacroQualifiedType(UT, T->getMacroIdentifier()));
+    }
+    case Type::MemberPointer: {
+      const auto *T = cast<MemberPointerType>(ST.Ty);
+      QualType CT = transform(QualType(T->getClass(), 0), Changed);
+      QualType PT = transform(T->getPointeeType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getMemberPointerType(PT, CT.getTypePtr()));
+    }
+    case Type::ObjCInterface:
+      return TT;
+    case Type::ObjCObject: {
+      const auto *T = cast<ObjCObjectType>(ST.Ty);
+      QualType BT = transform(T->getBaseType(), Changed);
+      auto Args = transform(T->getTypeArgs(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getObjCObjectType(
+          BT, Args, T->getProtocols(), T->isKindOfType()));
+    }
+    case Type::ObjCObjectPointer: {
+      const auto *T = cast<ObjCObjectPointerType>(ST.Ty);
+      QualType PT = transform(T->getPointeeType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getObjCObjectPointerType(PT));
+    }
+    case Type::ObjCTypeParam:
+      return TT;
+    case Type::PackExpansion: {
+      const auto *T = cast<PackExpansionType>(ST.Ty);
+      QualType P = transform(T->getPattern(), Changed);
+      if (!Changed)
+        return TT;
+      return build(
+          SemaRef.Context.getPackExpansionType(P, T->getNumExpansions()));
+    }
+    case Type::Paren: {
+      const auto *T = cast<ParenType>(ST.Ty);
+      QualType IT = transform(T->getInnerType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getParenType(IT));
+    }
+    case Type::Pipe: {
+      const auto *T = cast<PipeType>(ST.Ty);
+      QualType ET = transform(T->getElementType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getPipeType(ET, T->isReadOnly()));
+    }
+    case Type::Pointer: {
+      const auto *T = cast<PointerType>(ST.Ty);
+      QualType PT = transform(T->getPointeeType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getPointerType(PT));
+    }
+    case Type::Record:
+      return TT;
+    case Type::RValueReference: {
+      const auto *T = cast<RValueReferenceType>(ST.Ty);
+      QualType PT = transform(T->getPointeeTypeAsWritten(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getRValueReferenceType(PT));
+    }
+    case Type::SubstTemplateTypeParm: {
+      const auto *T = cast<SubstTemplateTypeParmType>(ST.Ty);
+      const auto *Arg = Names->getArgument(T->getAssociatedDecl(),
+                                           T->getIndex(), T->getPackIndex());
+      if (!Arg)
+        return TT;
+
+      SplitQualType Replacement = Arg->getAsType().split();
+      if (ST.Quals.hasObjCLifetime())
+        Replacement.Quals.removeObjCLifetime();
+      OutChanged = true;
+      return buildType(TT, Replacement.Ty, ST.Quals + Replacement.Quals);
+    }
+    case Type::SubstTemplateTypeParmPack: {
+      const auto *T = cast<SubstTemplateTypeParmPackType>(ST.Ty);
+      TemplateArgument P = transform(T->getArgumentPack(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getSubstTemplateTypeParmPackType(
+          T->getAssociatedDecl(), T->getIndex(), T->getFinal(), P));
+    }
+    case Type::TemplateTypeParm:
+      return TT;
+    case Type::TemplateSpecialization: {
+      const auto *T = cast<TemplateSpecializationType>(ST.Ty);
+      TemplateName TN = transform(T->getTemplateName(), Changed);
+      auto SpecArgs = transform(T->template_arguments(), Changed);
+      auto ConvertedArgs = transform(T->getConvertedArguments(), Changed);
+      QualType UT = T->desugar();
+      if (T->isTypeAlias())
+        UT = transform(UT, Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getTemplateSpecializationType(
+          TN, SpecArgs, ConvertedArgs,
+          /*CanonicalConvertedArgs=*/None, UT));
+    }
+    case Type::Typedef: {
+      const auto *T = cast<TypedefType>(ST.Ty);
+      QualType Underlying = transform(T->desugar(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getTypedefType(T->getDecl(), Underlying));
+    }
+    case Type::TypeOfExpr:
+      // FIXME: Resugar.
+      return TT;
+    case Type::TypeOf: {
+      const auto *T = cast<TypeOfType>(ST.Ty);
+      QualType UT = transform(T->getUnmodifiedType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getTypeOfType(UT, T->getKind()));
+    }
+    case Type::UnaryTransform: {
+      const auto *T = cast<UnaryTransformType>(ST.Ty);
+      QualType UT = transform(T->getUnderlyingType(), Changed);
+      if (!Changed)
+        return TT;
+      // FIXME: Handle BaseType.
+      return build(SemaRef.Context.getUnaryTransformType(T->getBaseType(), UT,
+                                                         T->getUTTKind()));
+    }
+    case Type::UnresolvedUsing:
+      return TT;
+    case Type::Using: {
+      const auto *T = cast<UsingType>(ST.Ty);
+      QualType Underlying = transform(T->desugar(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getUsingType(T->getFoundDecl(), Underlying));
+    }
+    case Type::VariableArray: {
+      const auto *T = cast<VariableArrayType>(ST.Ty);
+      QualType ET = transform(T->getElementType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getVariableArrayType(
+          ET, T->getSizeExpr(), T->getSizeModifier(),
+          T->getIndexTypeCVRQualifiers(), T->getBracketsRange()));
+    }
+    case Type::Vector: {
+      const auto *T = cast<VectorType>(ST.Ty);
+      QualType ET = transform(T->getElementType(), Changed);
+      if (!Changed)
+        return TT;
+      return build(SemaRef.Context.getVectorType(ET, T->getNumElements(),
+                                                 T->getVectorKind()));
+    }
+    }
+    llvm_unreachable("Unhandled TypeClass");
+  }
+
+  TemplateArgument transform(TemplateArgument A, bool &OutChanged) {
+    bool Changed = false;
+    switch (auto Kind = A.getKind()) {
+    case TemplateArgument::Null:
+      llvm_unreachable("Unexpected Null TemplateArgument");
+    case TemplateArgument::Pack: {
+      ArrayRef<TemplateArgument> PackArray = A.getPackAsArray();
+      if (PackArray.empty())
+        return A;
+      auto Pack = PackArray.copy(SemaRef.Context);
+      for (auto &PA : Pack)
+        PA = transform(PA, Changed);
+      if (!Changed)
+        return A;
+      OutChanged = true;
+      return TemplateArgument(Pack);
+    }
+    case TemplateArgument::Integral:
+    case TemplateArgument::NullPtr:
+    case TemplateArgument::Declaration: {
+      QualType T = transform(A.getNonTypeTemplateArgumentType(), Changed);
+      if (!Changed)
+        return A;
+      OutChanged = true;
+      switch (A.getKind()) {
+      case TemplateArgument::Integral:
+        return TemplateArgument(SemaRef.Context, A.getAsIntegral(), T);
+      case TemplateArgument::NullPtr:
+        return TemplateArgument(T, /*IsNullPtr=*/true);
+      case TemplateArgument::Declaration:
+        return TemplateArgument(A.getAsDecl(), T);
+      default:
+        llvm_unreachable("Not handled case");
+      }
+    }
+    case TemplateArgument::Type: {
+      QualType T = transform(A.getAsType(), Changed);
+      if (!Changed)
+        return A;
+      OutChanged = true;
+      return TemplateArgument(T);
+    }
+    case TemplateArgument::Template:
+    case TemplateArgument::TemplateExpansion: {
+      TemplateName TN = transform(A.getAsTemplateOrTemplatePattern(), Changed);
+      if (!Changed)
+        return A;
+      OutChanged = true;
+      return Kind == TemplateArgument::Template
+                 ? TemplateArgument(TN)
+                 : TemplateArgument(TN, A.getNumTemplateExpansions());
+    }
+    case TemplateArgument::Expression:
+      // FIXME: convert the type of these.
+      return A;
+    }
+    llvm_unreachable("Unexpected TemplateArgument kind");
+  }
+};
+} // namespace
+
+QualType Sema::resugar(const NestedNameSpecifier *NNS, QualType T) {
+  if (NNS == nullptr)
+    return T;
+
+  NameMap Names;
+  Names.insert(*this, NNS);
+  if (Names.empty())
+    return T;
+
+  bool Changed = false;
+  return Resugarer(*this, Names).transform(T, Changed);
+}
+
 /// \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,
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 SemaRef.Context.getTemplateSpecializationType(
         Name, TemplateArgs.arguments(), SugaredConverted, CanonicalConverted,
         Ts.getPackAsArray()[N].getAsType());
   }
   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") ||
TypeResult Sema::ActOnTagTemplateIdType(TagUseKind TUK,
 
   // 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);
   ElabTL.setElaboratedKeywordLoc(TagLoc);
   ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
   return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
 }
 
 static bool CheckTemplateSpecializationScope(Sema &S, NamedDecl *Specialized,
                                              NamedDecl *PrevDecl,
                                              SourceLocation Loc,
                                              bool IsPartialSpecialization);
 
 static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D);
 
 static bool isTemplateArgumentTemplateParameter(
     const TemplateArgument &Arg, unsigned Depth, unsigned Index) {
   switch (Arg.getKind()) {
   case TemplateArgument::Null:
   case TemplateArgument::NullPtr:
   case TemplateArgument::Integral:
   case TemplateArgument::Declaration:
   case TemplateArgument::Pack:
   case TemplateArgument::TemplateExpansion:
     return false;
 
   case TemplateArgument::Type: {
     QualType Type = Arg.getAsType();
     const TemplateTypeParmType *TPT =
         Arg.getAsType()->getAs<TemplateTypeParmType>();
if (TypeDecl *Type = dyn_cast<TypeDecl>(Result.getFoundDecl())) {
       // Unlike in an elaborated-type-specifier, function names are not ignored
       // in typename-specifier lookup. However, they are ignored in all the
       // contexts where we form a typename type with no keyword (that is, in
       // mem-initializer-ids, base-specifiers, and elaborated-type-specifiers).
       //
       // FIXME: That's not strictly true: mem-initializer-id lookup does not
       // ignore functions, but that appears to be an oversight.
       QualType T = getTypeDeclType(
-          Ctx,
+          SS.getScopeRep(), Ctx,
           Keyword == ETK_Typename ? DiagCtorKind::Typename : DiagCtorKind::None,
           Type, IILoc);
       // We found a type. Build an ElaboratedType, since the
       // typename-specifier was just sugar.
       return Context.getElaboratedType(
           Keyword, QualifierLoc.getNestedNameSpecifier(), T);
     }
 

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);

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/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/AST/ast-dump-openmp-begin-declare-variant_reference.cpp

 // CHECK-NEXT: | | |   `-BuiltinType [[ADDR_8]] 'float'
 // CHECK-NEXT: | | |-ParmVarDecl [[ADDR_43:0x[a-z0-9]*]] <col:6, col:12> col:12 used __t 'float &'
 // CHECK-NEXT: | | `-CompoundStmt [[ADDR_44:0x[a-z0-9]*]] <col:17, line:14:1>
 // CHECK-NEXT: | |   |-DeclStmt [[ADDR_45:0x[a-z0-9]*]] <line:12:3, col:51>
 // CHECK-NEXT: | |   | `-TypedefDecl [[ADDR_46:0x[a-z0-9]*]] <col:3, col:48> col:48 referenced _Up 'typename remove_reference<float &>::type':'float'
 // CHECK-NEXT: | |   |   `-ElaboratedType [[ADDR_47:0x[a-z0-9]*]] 'typename remove_reference<float &>::type' sugar
 // CHECK-NEXT: | |   |     `-TypedefType [[ADDR_48:0x[a-z0-9]*]] 'remove_reference<float &>::type' sugar
 // CHECK-NEXT: | |   |       |-Typedef [[ADDR_10]] 'type'
-// CHECK-NEXT: | |   |       `-SubstTemplateTypeParmType [[ADDR_11]] 'float' sugar class depth 0 index 0 _Tp
-// CHECK-NEXT: | |   |         |-ClassTemplateSpecialization [[ADDR_6]] 'remove_reference'
-// CHECK-NEXT: | |   |         `-BuiltinType [[ADDR_8]] 'float'
+// CHECK-NEXT: | |   |       `-BuiltinType [[ADDR_8]] 'float'
 // CHECK-NEXT: | |   `-ReturnStmt [[ADDR_49:0x[a-z0-9]*]] <line:13:3, col:33>
 // CHECK-NEXT: | |     `-CXXStaticCastExpr [[ADDR_50:0x[a-z0-9]*]] <col:10, col:33> '_Up':'float' xvalue static_cast<_Up &&> <NoOp>
 // CHECK-NEXT: | |       `-DeclRefExpr [[ADDR_51:0x[a-z0-9]*]] <col:30> 'float' {{.*}}ParmVar [[ADDR_43]] '__t' 'float &'
 // CHECK-NEXT: | `-FunctionDecl [[ADDR_52:0x[a-z0-9]*]] <line:10:1, line:14:1> line:11:1 used move 'typename remove_reference<short &>::type &&(short &)' inline
 // CHECK-NEXT: |   |-TemplateArgument type 'short &'
 // CHECK-NEXT: |   | `-LValueReferenceType [[ADDR_15]] 'short &'
 // CHECK-NEXT: |   |   `-BuiltinType [[ADDR_16]] 'short'
 // CHECK-NEXT: |   |-ParmVarDecl [[ADDR_53:0x[a-z0-9]*]] <col:6, col:12> col:12 used __t 'short &'
 // CHECK-NEXT: |   `-CompoundStmt [[ADDR_54:0x[a-z0-9]*]] <col:17, line:14:1>
 // CHECK-NEXT: |     |-DeclStmt [[ADDR_55:0x[a-z0-9]*]] <line:12:3, col:51>
 // CHECK-NEXT: |     | `-TypedefDecl [[ADDR_56:0x[a-z0-9]*]] <col:3, col:48> col:48 referenced _Up 'typename remove_reference<short &>::type':'short'
 // CHECK-NEXT: |     |   `-ElaboratedType [[ADDR_57:0x[a-z0-9]*]] 'typename remove_reference<short &>::type' sugar
 // CHECK-NEXT: |     |     `-TypedefType [[ADDR_58:0x[a-z0-9]*]] 'remove_reference<short &>::type' sugar
 // CHECK-NEXT: |     |       |-Typedef [[ADDR_18]] 'type'
-// CHECK-NEXT: |     |       `-SubstTemplateTypeParmType [[ADDR_19]] 'short' sugar class depth 0 index 0 _Tp
-// CHECK-NEXT: |     |         |-ClassTemplateSpecialization [[ADDR_14]] 'remove_reference'
-// CHECK-NEXT: |     |         `-BuiltinType [[ADDR_16]] 'short'
+// CHECK-NEXT: |     |       `-BuiltinType [[ADDR_16]] 'short'
 // CHECK-NEXT: |     `-ReturnStmt [[ADDR_59:0x[a-z0-9]*]] <line:13:3, col:33>
 // CHECK-NEXT: |       `-CXXStaticCastExpr [[ADDR_60:0x[a-z0-9]*]] <col:10, col:33> '_Up':'short' xvalue static_cast<_Up &&> <NoOp>
 // CHECK-NEXT: |         `-DeclRefExpr [[ADDR_61:0x[a-z0-9]*]] <col:30> 'short' {{.*}}ParmVar [[ADDR_53]] '__t' 'short &'
 // CHECK-NEXT: |-VarDecl [[ADDR_62:0x[a-z0-9]*]] <line:17:1, col:5> col:5 used Good 'int'
 // CHECK-NEXT: |-VarDecl [[ADDR_63:0x[a-z0-9]*]] <col:1, col:11> col:11 used Bad 'int'
 // CHECK-NEXT: |-FunctionDecl [[ADDR_64:0x[a-z0-9]*]] <line:18:1, line:20:1> line:18:6 used also_before 'int &({{.*}})'
 // CHECK-NEXT: | |-CompoundStmt [[ADDR_65:0x[a-z0-9]*]] <col:20, line:20:1>
 // CHECK-NEXT: | | `-ReturnStmt [[ADDR_66:0x[a-z0-9]*]] <line:19:3, col:10>

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

+// RUN: %clang_cc1 -std=c++2b -fms-extensions -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_NOT(T1::type2); // FIXME: Needs resugaring on the pattern of template type aliases.
+
+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_NOT(T1::type2); // FIXME: Needs resugaring on the pattern of template type aliases.
+
+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_NOT(typename T1::type2); // FIXME: Needs resugaring on the pattern of template type aliases.
+
+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
+
+namespace t19 {
+template <class T> struct A { using type = T&; };
+
+TEST_NOT(A<Bar __unaligned>::type);
+} // namespace t19

libcxx/DELETE.ME

+D127695

lldb/test/API/commands/expression/import-std-module/iterator/TestIteratorFromStdModule.py

def test(self):
                                           "// Set break point at this line.",
                                           lldb.SBFileSpec("main.cpp"))
 
         self.runCmd("settings set target.import-std-module true")
 
         iter_type = "std::move_iterator<std::__wrap_iter<int *> >"
 
         self.expect_expr("move_begin", result_type=iter_type)
-        self.expect_expr("move_begin[0]", result_type="int", result_value="1")
+        self.expect_expr("move_begin[0]", result_type="__libcpp_remove_reference_t<__reference>", result_value="1")
 
         self.expect_expr("move_begin + 3 == move_end", result_value="true")
 
         self.expect("expr move_begin++")
         self.expect_expr("move_begin + 2 == move_end", result_value="true")
         self.expect("expr move_begin--")
         self.expect_expr("move_begin + 3 == move_end", result_value="true")