[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

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?

997–1003

Move back up?

clang/lib/Sema/SemaExpr.cpp

3436–3439

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

20635

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

clang/lib/Sema/SemaExprMember.cpp

1858

Rename to FieldQuals

clang/lib/Sema/SemaOverload.cpp

15294–15295

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

4703–4705

Change back to original?

5290–5305

Move back up?

clang/lib/Sema/TreeTransform.h

2683–2685

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

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.

BROKEN

+CXX/temp/temp.decls/temp.variadic/example-tuple.cpp
+CXX/temp/temp.decls/temp.variadic/metafunctions.cpp
+PCH/cxx-chain-function-template.cpp
+SemaCXX/calling-conv-compat.cpp
+SemaTemplate/example-typelist.cpp

clang-tools-extra/clangd/unittests/HoverTests.cpp

class Foo {})cpp";
           using ^[[AA]] = A<T>;
          )cpp",
        [](HoverInfo &HI) {
          HI.Name = "AA";
          HI.NamespaceScope = "";
          HI.LocalScope = "";
          HI.Kind = index::SymbolKind::TypeAlias;
          HI.Definition = "template <typename T> using AA = A<T>";
-         HI.Type = {"A<T>", "type-parameter-0-0"}; // FIXME: should be 'T'
+         HI.Type = {"A<T>", "T"};
          HI.TemplateParameters = {{{"typename"}, std::string("T"), llvm::None}};
        }},
       {// Constant array
        R"cpp(
           using m_int = int;
 
           m_int ^[[arr]][10];
          )cpp",

clang/include/clang/AST/DeclTemplate.h

static bool classofKind(Kind K) {
     return K >= firstTemplate && K <= lastTemplate;
   }
 
   SourceRange getSourceRange() const override LLVM_READONLY {
     return SourceRange(getTemplateParameters()->getTemplateLoc(),
                        TemplatedDecl->getSourceRange().getEnd());
   }
 
+  bool isTypeAlias() const;
+
 protected:
   NamedDecl *TemplatedDecl;
   TemplateParameterList *TemplateParams;
 
   void setTemplateParameters(TemplateParameterList *TParams) {
     TemplateParams = TParams;
   }
 

clang/include/clang/AST/TemplateBase.h

 
 public:
   TemplateArgumentListInfo() = default;
 
   TemplateArgumentListInfo(SourceLocation LAngleLoc,
                            SourceLocation RAngleLoc)
       : LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc) {}
 
+  TemplateArgumentListInfo(TemplateArgumentListInfo &&) = default;
+  TemplateArgumentListInfo &operator=(TemplateArgumentListInfo &&) = default;
+  TemplateArgumentListInfo(const TemplateArgumentListInfo &) = default;
+  TemplateArgumentListInfo &
+  operator=(const TemplateArgumentListInfo &) = default;
+
   // This can leak if used in an AST node, use ASTTemplateArgumentListInfo
   // instead.
   void *operator new(size_t bytes, ASTContext &C) = delete;
 
   SourceLocation getLAngleLoc() const { return LAngleLoc; }
   SourceLocation getRAngleLoc() const { return RAngleLoc; }
 
   void setLAngleLoc(SourceLocation Loc) { LAngleLoc = Loc; }

clang/include/clang/AST/Type.h

class AutoTypeBitfields {
     /// However as this limit is somewhat easy to hit with template
     /// metaprogramming we'd prefer to keep it as large as possible.
     /// At the moment it has been left as a non-bitfield since this type
     /// safely fits in 64 bits as an unsigned, so there is no reason to
     /// introduce the performance impact of a bitfield.
     unsigned NumArgs;
   };
 
+  class UsingBitfields {
+    friend class UsingType;
+
+    unsigned : NumTypeBits;
+
+    /// True if this UsingType has underlying type different from decl.
+    unsigned hasDifferentUnderlyingType : 1;
+  };
+
+  class TypedefBitfields {
+    friend class TypedefType;
+
+    unsigned : NumTypeBits;
+
+    /// True if this typedef has underlying type different from decl.
+    unsigned hasDifferentUnderlyingType : 1;
+  };
+
   class SubstTemplateTypeParmTypeBitfields {
     friend class SubstTemplateTypeParmType;
 
     unsigned : NumTypeBits;
 
     /// Represents the index within a pack if this represents a substitution
     /// from a pack expansion.
     /// Positive non-zero number represents the index + 1.
protected:
   };
 
   union {
     TypeBitfields TypeBits;
     ArrayTypeBitfields ArrayTypeBits;
     ConstantArrayTypeBitfields ConstantArrayTypeBits;
     AttributedTypeBitfields AttributedTypeBits;
     AutoTypeBitfields AutoTypeBits;
+    TypedefBitfields TypedefBits;
+    UsingBitfields UsingBits;
     BuiltinTypeBitfields BuiltinTypeBits;
     FunctionTypeBitfields FunctionTypeBits;
     ObjCObjectTypeBitfields ObjCObjectTypeBits;
     ReferenceTypeBitfields ReferenceTypeBits;
     TypeWithKeywordBitfields TypeWithKeywordBits;
     ElaboratedTypeBitfields ElaboratedTypeBits;
     VectorTypeBitfields VectorTypeBits;
     SubstTemplateTypeParmPackTypeBitfields SubstTemplateTypeParmPackTypeBits;

 class UsingType : public Type, public llvm::FoldingSetNode {
   UsingShadowDecl *Found;
   friend class ASTContext; // ASTContext creates these.
 
   UsingType(const UsingShadowDecl *Found, QualType Underlying, QualType Canon);
 
 public:
   UsingShadowDecl *getFoundDecl() const { return Found; }
+  bool hasDifferentUnderlyingType() const {
+    return UsingBits.hasDifferentUnderlyingType;
+  }
   QualType getUnderlyingType() const;
 
   bool isSugared() const { return true; }
   QualType desugar() const { return getUnderlyingType(); }
 
-  void Profile(llvm::FoldingSetNodeID &ID) { Profile(ID, Found); }
-  static void Profile(llvm::FoldingSetNodeID &ID,
-                      const UsingShadowDecl *Found) {
+  void Profile(llvm::FoldingSetNodeID &ID) {
+    Profile(ID, Found, getUnderlyingType());
+  }
+  static void Profile(llvm::FoldingSetNodeID &ID, const UsingShadowDecl *Found,
+                      QualType Underlying) {
     ID.AddPointer(Found);
+    Underlying.Profile(ID);
   }
   static bool classof(const Type *T) { return T->getTypeClass() == Using; }
 };
 
 class TypedefType : public Type {
   TypedefNameDecl *Decl;
 
 private:
   friend class ASTContext; // ASTContext creates these.
 
   TypedefType(TypeClass tc, const TypedefNameDecl *D, QualType underlying,
               QualType can);
 
 public:
   TypedefNameDecl *getDecl() const { return Decl; }
+  bool hasDifferentUnderlyingType() const {
+    return TypedefBits.hasDifferentUnderlyingType;
+  }
 
   bool isSugared() const { return true; }
   QualType desugar() const;
 
   static bool classof(const Type *T) { return T->getTypeClass() == Typedef; }
 };
 
 /// Sugar type that represents a type that was qualified by a qualifier written

 /// been replaced with these.  They are used solely to record that a
 /// type was originally written as a template type parameter;
 /// therefore they are never canonical.
 class SubstTemplateTypeParmType : public Type, public llvm::FoldingSetNode {
   friend class ASTContext;
 
   // The original type parameter.
   const TemplateTypeParmType *Replaced;
+  QualType Replacement;
 
-  SubstTemplateTypeParmType(const TemplateTypeParmType *Param, QualType Canon,
-                            Optional<unsigned> PackIndex)
-      : Type(SubstTemplateTypeParm, Canon, Canon->getDependence()),
-        Replaced(Param) {
+  SubstTemplateTypeParmType(const TemplateTypeParmType *Param,
+                            QualType Replacement, Optional<unsigned> PackIndex)
+      : Type(SubstTemplateTypeParm, Replacement.getCanonicalType(),
+             Replacement->getDependence()),
+        Replaced(Param), Replacement(Replacement) {
     SubstTemplateTypeParmTypeBits.PackIndex = PackIndex ? *PackIndex + 1 : 0;
   }
 
 public:
   /// Gets the template parameter that was substituted for.
   const TemplateTypeParmType *getReplacedParameter() const {
     return Replaced;
   }
 
   /// Gets the type that was substituted for the template
   /// parameter.
-  QualType getReplacementType() const {
-    return getCanonicalTypeInternal();
-  }
+  QualType getReplacementType() const { return Replacement; }
 
   Optional<unsigned> getPackIndex() const {
     if (SubstTemplateTypeParmTypeBits.PackIndex == 0U)
       return None;
     return SubstTemplateTypeParmTypeBits.PackIndex - 1U;
   }
 
   bool isSugared() const { return true; }

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/AST/TypeProperties.td

def : Creator<[{
     return ctx.getUsingType(foundDeclaration, underlyingType);
   }]>;
 }
 
 let Class = TypedefType in {
   def : Property<"declaration", DeclRef> {
     let Read = [{ node->getDecl() }];
   }
-  def : Property<"canonicalType", Optional<QualType>> {
-    let Read = [{ makeOptionalFromNullable(node->getCanonicalTypeInternal()) }];
+  def : Property<"underlyingType", QualType> {
+    let Read = [{ node->desugar() }];
   }
 
   def : Creator<[{
-    QualType finalCanonicalType =
-      canonicalType ? ctx.getCanonicalType(*canonicalType)
-                    : QualType();
-    return ctx.getTypedefType(cast<TypedefNameDecl>(declaration),
-                              finalCanonicalType);
+    return ctx.getTypedefType(cast<TypedefNameDecl>(declaration), underlyingType);
   }]>;
 }
 
 let Class = TypeOfExprType in {
   def : Property<"expression", ExprRef> {
     let Read = [{ node->getUnderlyingExpr() }];
   }
 
let Class = SubstTemplateTypeParmType in {
   def : Property<"replacementType", QualType> {
     let Read = [{ node->getReplacementType() }];
   }
   def : Property<"PackIndex", Optional<UInt32>> {
     let Read = [{ node->getPackIndex() }];
   }
 
   def : Creator<[{
-    // The call to getCanonicalType here existed in ASTReader.cpp, too.
     return ctx.getSubstTemplateTypeParmType(
-        cast<TemplateTypeParmType>(replacedParameter),
-        ctx.getCanonicalType(replacementType), PackIndex);
+        cast<TemplateTypeParmType>(replacedParameter), replacementType, PackIndex);
   }]>;
 }
 
 let Class = PackExpansionType in {
   def : Property<"pattern", QualType> {
     let Read = [{ node->getPattern() }];
   }
   def : Property<"numExpansions", Optional<UInt32>> {

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

union {
 
       /// FinalConversion - For a conversion function (where Function is
       /// a CXXConversionDecl), the standard conversion that occurs
       /// after the call to the overload candidate to convert the result
       /// of calling the conversion function to the required type.
       StandardConversionSequence FinalConversion;
     };
 
+    /// Deduced Arguments for Function Templates.
+    const TemplateArgumentList *Deduced;
+
     /// Get RewriteKind value in OverloadCandidateRewriteKind type (This
     /// function is to workaround the spurious GCC bitfield enum warning)
     OverloadCandidateRewriteKind getRewriteKind() const {
       return static_cast<OverloadCandidateRewriteKind>(RewriteKind);
     }
 
     bool isReversed() const { return getRewriteKind() & CRK_Reversed; }
 

clang/include/clang/Sema/Sema.h

void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl,
                             ArrayRef<Expr *> Args,
                             OverloadCandidateSet &CandidateSet,
                             bool SuppressUserConversions = false,
                             bool PartialOverloading = false,
                             bool AllowExplicit = true,
                             bool AllowExplicitConversion = false,
                             ADLCallKind IsADLCandidate = ADLCallKind::NotADL,
                             ConversionSequenceList EarlyConversions = None,
-                            OverloadCandidateParamOrder PO = {});
+                            OverloadCandidateParamOrder PO = {},
+                            const TemplateArgumentList *Deduced = nullptr);
   void AddFunctionCandidates(const UnresolvedSetImpl &Functions,
                       ArrayRef<Expr *> Args,
                       OverloadCandidateSet &CandidateSet,
                       TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr,
                       bool SuppressUserConversions = false,
                       bool PartialOverloading = false,
                       bool FirstArgumentIsBase = false);
   void AddMethodCandidate(DeclAccessPair FoundDecl,
                           QualType ObjectType,
                           Expr::Classification ObjectClassification,
                           ArrayRef<Expr *> Args,
                           OverloadCandidateSet& CandidateSet,
                           bool SuppressUserConversion = false,
                           OverloadCandidateParamOrder PO = {});
-  void AddMethodCandidate(CXXMethodDecl *Method,
-                          DeclAccessPair FoundDecl,
+  void AddMethodCandidate(CXXMethodDecl *Method, DeclAccessPair FoundDecl,
                           CXXRecordDecl *ActingContext, QualType ObjectType,
                           Expr::Classification ObjectClassification,
                           ArrayRef<Expr *> Args,
-                          OverloadCandidateSet& CandidateSet,
+                          OverloadCandidateSet &CandidateSet,
                           bool SuppressUserConversions = false,
                           bool PartialOverloading = false,
                           ConversionSequenceList EarlyConversions = None,
-                          OverloadCandidateParamOrder PO = {});
+                          OverloadCandidateParamOrder PO = {},
+                          const TemplateArgumentList *Deduced = nullptr);
   void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl,
                                   DeclAccessPair FoundDecl,
                                   CXXRecordDecl *ActingContext,
                                  TemplateArgumentListInfo *ExplicitTemplateArgs,
                                   QualType ObjectType,
                                   Expr::Classification ObjectClassification,
                                   ArrayRef<Expr *> Args,
                                   OverloadCandidateSet& CandidateSet,
ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr,
                                      bool *pHadMultipleCandidates = nullptr);
 
   FunctionDecl *
   resolveAddressOfSingleOverloadCandidate(Expr *E, DeclAccessPair &FoundResult);
 
   bool resolveAndFixAddressOfSingleOverloadCandidate(
       ExprResult &SrcExpr, bool DoFunctionPointerConversion = false);
 
-  FunctionDecl *
-  ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl,
-                                              bool Complain = false,
-                                              DeclAccessPair *Found = nullptr);
+  FunctionDecl *ResolveSingleFunctionTemplateSpecialization(
+      OverloadExpr *ovl, TemplateArgumentListInfo &ExplicitTemplateArgs,
+      bool Complain = false, DeclAccessPair *Found = nullptr);
 
   bool ResolveAndFixSingleFunctionTemplateSpecialization(
                       ExprResult &SrcExpr,
                       bool DoFunctionPointerConverion = false,
                       bool Complain = false,
                       SourceRange OpRangeForComplaining = SourceRange(),
                       QualType DestTypeForComplaining = QualType(),
                       unsigned DiagIDForComplaining = 0);
 
-
-  Expr *FixOverloadedFunctionReference(Expr *E,
-                                       DeclAccessPair FoundDecl,
-                                       FunctionDecl *Fn);
-  ExprResult FixOverloadedFunctionReference(ExprResult,
-                                            DeclAccessPair FoundDecl,
-                                            FunctionDecl *Fn);
+  Expr *FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl,
+                                       FunctionDecl *Fn,
+                                       const TemplateArgumentList *Deduced);
+  ExprResult
+  FixOverloadedFunctionReference(ExprResult, DeclAccessPair FoundDecl,
+                                 FunctionDecl *Fn,
+                                 const TemplateArgumentList *Deduced);
 
   void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE,
                                    ArrayRef<Expr *> Args,
                                    OverloadCandidateSet &CandidateSet,
                                    bool PartialOverloading = false);
   void AddOverloadedCallCandidates(
       LookupResult &R, TemplateArgumentListInfo *ExplicitTemplateArgs,
       ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet);
BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc,
                            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,
+                                     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);
 
enum CheckTemplateArgumentKind {
     /// deduction.
     CTAK_Deduced,
 
     /// The template argument was deduced from an array bound
     /// via template argument deduction.
     CTAK_DeducedFromArrayBound
   };
 
-  bool CheckTemplateArgument(NamedDecl *Param,
-                             TemplateArgumentLoc &Arg,
-                             NamedDecl *Template,
-                             SourceLocation TemplateLoc,
+  bool CheckTemplateArgument(NamedDecl *Param, TemplateArgumentLoc &Arg,
+                             NamedDecl *Template, SourceLocation TemplateLoc,
                              SourceLocation RAngleLoc,
                              unsigned ArgumentPackIndex,
                              SmallVectorImpl<TemplateArgument> &Converted,
-                             CheckTemplateArgumentKind CTAK = CTAK_Specified);
+                             CheckTemplateArgumentKind CTAK,
+                             bool DontCanonicalize);
 
   /// Check that the given template arguments can be be provided to
   /// the given template, converting the arguments along the way.
   ///
   /// \param Template The template to which the template arguments are being
   /// provided.
   ///
   /// \param TemplateLoc The location of the template name in the source.

   ///
   /// \returns true if an error occurred, false otherwise.
   bool CheckTemplateArgumentList(TemplateDecl *Template,
                                  SourceLocation TemplateLoc,
                                  TemplateArgumentListInfo &TemplateArgs,
                                  bool PartialTemplateArgs,
                                  SmallVectorImpl<TemplateArgument> &Converted,
                                  bool UpdateArgsWithConversions = true,
-                                 bool *ConstraintsNotSatisfied = nullptr);
+                                 bool *ConstraintsNotSatisfied = nullptr,
+                                 bool DontCanonicalize = false);
 
   bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,
                                  TemplateArgumentLoc &Arg,
-                           SmallVectorImpl<TemplateArgument> &Converted);
+                                 SmallVectorImpl<TemplateArgument> &Converted,
+                                 bool DontCanonizalize);
 
   bool CheckTemplateArgument(TypeSourceInfo *Arg);
   ExprResult CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
                                    QualType InstantiatedParamType, Expr *Arg,
                                    TemplateArgument &Converted,
-                               CheckTemplateArgumentKind CTAK = CTAK_Specified);
+                                   CheckTemplateArgumentKind CTAK,
+                                   bool DontCanonizalize);
   bool CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
                                      TemplateParameterList *Params,
                                      TemplateArgumentLoc &Arg);
 
   ExprResult
   BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg,
                                           QualType ParamType,
                                           SourceLocation Loc);
enum TemplateDeductionResult {
     TDK_MiscellaneousDeductionFailure,
     /// CUDA Target attributes do not match.
     TDK_CUDATargetMismatch
   };
 
   TemplateDeductionResult
   DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
                           const TemplateArgumentList &TemplateArgs,
-                          sema::TemplateDeductionInfo &Info);
+                          sema::TemplateDeductionInfo &Info,
+                          bool DontCanonicalize = false);
 
   TemplateDeductionResult
   DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial,
                           const TemplateArgumentList &TemplateArgs,
-                          sema::TemplateDeductionInfo &Info);
+                          sema::TemplateDeductionInfo &Info,
+                          bool DontCanonicalize = false);
 
   TemplateDeductionResult SubstituteExplicitTemplateArguments(
       FunctionTemplateDecl *FunctionTemplate,
       TemplateArgumentListInfo &ExplicitTemplateArgs,
       SmallVectorImpl<DeducedTemplateArgument> &Deduced,
       SmallVectorImpl<QualType> &ParamTypes, QualType *FunctionType,
       sema::TemplateDeductionInfo &Info);
 
public:
     const FunctionProtoType::ExtParameterInfo *
     getPointerOrNull(unsigned numParams) {
       if (!HasInteresting) return nullptr;
       Infos.resize(numParams);
       return Infos.data();
     }
   };
 
+  QualType resugar(const CXXScopeSpec &SS, NamedDecl *ND,
+                   const TemplateArgumentListInfo *Args, QualType T,
+                   bool Escapes = false, bool AsWritten = true);
+  QualType resugarEscapes(QualType T);
+  bool resugarTemplateArguments(const CXXScopeSpec &SS,
+                                TemplateArgumentListInfo &Args);
+
   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

#include "clang/Basic/RISCVVTypes.def"
 
   case Type::ObjCTypeParam:
     return getTypeInfo(cast<ObjCTypeParamType>(T)->desugar().getTypePtr());
 
   case Type::Using:
     return getTypeInfo(cast<UsingType>(T)->desugar().getTypePtr());
 
   case Type::Typedef: {
-    const TypedefNameDecl *Typedef = cast<TypedefType>(T)->getDecl();
-    TypeInfo Info = getTypeInfo(Typedef->getUnderlyingType().getTypePtr());
+    const auto *TT = cast<TypedefType>(T);
+    TypeInfo Info = getTypeInfo(TT->desugar().getTypePtr());
     // If the typedef has an aligned attribute on it, it overrides any computed
     // alignment we have.  This violates the GCC documentation (which says that
     // attribute(aligned) can only round up) but matches its implementation.
-    if (unsigned AttrAlign = Typedef->getMaxAlignment()) {
+    if (unsigned AttrAlign = TT->getDecl()->getMaxAlignment()) {
       Align = AttrAlign;
       AlignRequirement = AlignRequirementKind::RequiredByTypedef;
     } else {
       Align = Info.Align;
       AlignRequirement = Info.AlignRequirement;
     }
     Width = Info.Width;
     break;
QualType ASTContext::getTypeDeclTypeSlow(const TypeDecl *Decl) const {
 
   return QualType(Decl->TypeForDecl, 0);
 }
 
 /// getTypedefType - Return the unique reference to the type for the
 /// specified typedef name decl.
 QualType ASTContext::getTypedefType(const TypedefNameDecl *Decl,
                                     QualType Underlying) const {
-  if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
-
+  if (!Decl->TypeForDecl) {
     if (Underlying.isNull())
       Underlying = Decl->getUnderlyingType();
-  QualType Canonical = getCanonicalType(Underlying);
-  auto *newType = new (*this, TypeAlignment)
-      TypedefType(Type::Typedef, Decl, Underlying, Canonical);
+    auto *newType = new (*this, TypeAlignment) TypedefType(
+        Type::Typedef, Decl, QualType(), getCanonicalType(Underlying));
     Decl->TypeForDecl = newType;
     Types.push_back(newType);
     return QualType(newType, 0);
   }
+  if (Underlying.isNull())
+    return QualType(Decl->TypeForDecl, 0);
+  if (Decl->getUnderlyingType() == Underlying)
+    return QualType(Decl->TypeForDecl, 0);
+
+  // FIXME: Unique
+  void *Mem = Allocate(sizeof(TypedefType) + sizeof(QualType), TypeAlignment);
+  auto *newType = new (Mem) TypedefType(Type::Typedef, Decl, Underlying,
+                                        getCanonicalType(Underlying));
+  Types.push_back(newType);
+  return QualType(newType, 0);
+}
 
 QualType ASTContext::getUsingType(const UsingShadowDecl *Found,
                                   QualType Underlying) const {
   llvm::FoldingSetNodeID ID;
-  UsingType::Profile(ID, Found);
+  UsingType::Profile(ID, Found, Underlying);
 
   void *InsertPos = nullptr;
   UsingType *T = UsingTypes.FindNodeOrInsertPos(ID, InsertPos);
   if (T)
     return QualType(T, 0);
 
   assert(!Underlying.hasLocalQualifiers());
-  assert(Underlying == getTypeDeclType(cast<TypeDecl>(Found->getTargetDecl())));
   QualType Canon = Underlying.getCanonicalType();
-
-  UsingType *NewType =
-      new (*this, TypeAlignment) UsingType(Found, Underlying, Canon);
+  if (Underlying.getTypePtr() ==
+      cast<TypeDecl>(Found->getTargetDecl())->getTypeForDecl())
+    Underlying = QualType();
+  void *Mem = Allocate(sizeof(UsingType) +
+                           (!Underlying.isNull() ? sizeof(QualType) : 0),
+                       TypeAlignment);
+  UsingType *NewType = new (Mem) UsingType(Found, Underlying, Canon);
   Types.push_back(NewType);
   UsingTypes.InsertNode(NewType, InsertPos);
   return QualType(NewType, 0);
 }
 
 QualType ASTContext::getRecordType(const RecordDecl *Decl) const {
   if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
 
QualType ASTContext::getBTFTagAttributedType(const BTFTypeTagAttr *BTFAttr,
   return QualType(Ty, 0);
 }
 
 /// Retrieve a substitution-result type.
 QualType
 ASTContext::getSubstTemplateTypeParmType(const TemplateTypeParmType *Parm,
                                          QualType Replacement,
                                          Optional<unsigned> PackIndex) const {
-  assert(Replacement.isCanonical()
-         && "replacement types must always be canonical");
-
   llvm::FoldingSetNodeID ID;
   SubstTemplateTypeParmType::Profile(ID, Parm, Replacement, PackIndex);
   void *InsertPos = nullptr;
   SubstTemplateTypeParmType *SubstParm
     = SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
 
   if (!SubstParm) {
     SubstParm = new (*this, TypeAlignment)
ASTContext::getTemplateSpecializationType(TemplateName Template,
                                           ArrayRef<TemplateArgument> Args,
                                           QualType Underlying) const {
   assert(!Template.getAsDependentTemplateName() &&
          "No dependent template names here!");
   // Look through qualified template names.
   if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
     Template = QTN->getUnderlyingTemplate();
 
-  bool IsTypeAlias =
-      isa_and_nonnull<TypeAliasTemplateDecl>(Template.getAsTemplateDecl());
+  const auto *TD = Template.getAsTemplateDecl();
+  bool IsTypeAlias = TD && TD->isTypeAlias();
   QualType CanonType;
   if (!Underlying.isNull())
     CanonType = getCanonicalType(Underlying);
   else {
     // We can get here with an alias template when the specialization contains
     // a pack expansion that does not match up with a parameter pack.
     assert((!IsTypeAlias || hasAnyPackExpansions(Args)) &&
            "Caller must compute aliased type");
if (ObjCSuperType.isNull()) {
     ObjCSuperType = getTagDeclType(ObjCSuperTypeDecl);
   }
   return ObjCSuperType;
 }
 
 void ASTContext::setCFConstantStringType(QualType T) {
   const auto *TD = T->castAs<TypedefType>();
   CFConstantStringTypeDecl = cast<TypedefDecl>(TD->getDecl());
-  const auto *TagType =
-      CFConstantStringTypeDecl->getUnderlyingType()->castAs<RecordType>();
+  const auto *TagType = TD->castAs<RecordType>();
   CFConstantStringTagDecl = TagType->getDecl();
 }
 
 QualType ASTContext::getBlockDescriptorType() const {
   if (BlockDescriptorType)
     return getTagDeclType(BlockDescriptorType);
 
   RecordDecl *RD;

clang/lib/AST/ASTImporter.cpp

ExpectedType ASTNodeImporter::VisitParenType(const ParenType *T) {
 
   return Importer.getToContext().getParenType(*ToInnerTypeOrErr);
 }
 
 ExpectedType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
   Expected<TypedefNameDecl *> ToDeclOrErr = import(T->getDecl());
   if (!ToDeclOrErr)
     return ToDeclOrErr.takeError();
+  ExpectedType ToUnderlyingTypeOrErr = import(T->desugar());
+  if (!ToUnderlyingTypeOrErr)
+    return ToUnderlyingTypeOrErr.takeError();
 
-  return Importer.getToContext().getTypeDeclType(*ToDeclOrErr);
+  return Importer.getToContext().getTypedefType(*ToDeclOrErr,
+                                                *ToUnderlyingTypeOrErr);
 }
 
 ExpectedType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
   ExpectedExpr ToExprOrErr = import(T->getUnderlyingExpr());
   if (!ToExprOrErr)
     return ToExprOrErr.takeError();
 
   return Importer.getToContext().getTypeOfExprType(*ToExprOrErr);
ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmType(
   if (!ReplacedOrErr)
     return ReplacedOrErr.takeError();
 
   ExpectedType ToReplacementTypeOrErr = import(T->getReplacementType());
   if (!ToReplacementTypeOrErr)
     return ToReplacementTypeOrErr.takeError();
 
   return Importer.getToContext().getSubstTemplateTypeParmType(
-      *ReplacedOrErr, ToReplacementTypeOrErr->getCanonicalType(),
-      T->getPackIndex());
+      *ReplacedOrErr, *ToReplacementTypeOrErr, T->getPackIndex());
 }
 
 ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmPackType(
     const SubstTemplateTypeParmPackType *T) {
   Expected<const TemplateTypeParmType *> ReplacedOrErr =
       import(T->getReplacedParameter());
   if (!ReplacedOrErr)
     return ReplacedOrErr.takeError();

clang/lib/AST/ASTStructuralEquivalence.cpp

if (!IsStructurallyEquivalent(
             cast<MacroQualifiedType>(T2)->getUnderlyingType()))
       return false;
     break;
 
   case Type::Using:
     if (!IsStructurallyEquivalent(Context, cast<UsingType>(T1)->getFoundDecl(),
                                   cast<UsingType>(T2)->getFoundDecl()))
       return false;
+    if (!IsStructurallyEquivalent(Context,
+                                  cast<UsingType>(T1)->getUnderlyingType(),
+                                  cast<UsingType>(T2)->getUnderlyingType()))
+      return false;
     break;
 
   case Type::Typedef:
     if (!IsStructurallyEquivalent(Context, cast<TypedefType>(T1)->getDecl(),
-                                  cast<TypedefType>(T2)->getDecl()))
+                                  cast<TypedefType>(T2)->getDecl()) ||
+        !IsStructurallyEquivalent(Context, cast<TypedefType>(T1)->desugar(),
+                                  cast<TypedefType>(T2)->desugar()))
       return false;
     break;
 
   case Type::TypeOfExpr:
     if (!IsStructurallyEquivalent(
             Context, cast<TypeOfExprType>(T1)->getUnderlyingExpr(),
             cast<TypeOfExprType>(T2)->getUnderlyingExpr()))
       return false;

clang/lib/AST/DeclTemplate.cpp

 bool TemplateDecl::hasAssociatedConstraints() const {
   if (TemplateParams->hasAssociatedConstraints())
     return true;
   if (auto *FD = dyn_cast_or_null<FunctionDecl>(getTemplatedDecl()))
     return FD->getTrailingRequiresClause();
   return false;
 }
 
+bool TemplateDecl::isTypeAlias() const {
+  switch (getKind()) {
+  case TemplateDecl::TypeAliasTemplate:
+    return true;
+  case TemplateDecl::BuiltinTemplate: {
+    const auto *BT = cast<BuiltinTemplateDecl>(this);
+    if (BT->getBuiltinTemplateKind() ==
+        BuiltinTemplateKind::BTK__make_integer_seq)
+      return true;
+    return false;
+  }
+  default:
+    return false;
+  };
+  llvm_unreachable("unknown template kind");
+}
+
 //===----------------------------------------------------------------------===//
 // RedeclarableTemplateDecl Implementation
 //===----------------------------------------------------------------------===//
 
 void RedeclarableTemplateDecl::anchor() {}
 
 RedeclarableTemplateDecl::CommonBase *RedeclarableTemplateDecl::getCommonPtr() const {
   if (Common)

clang/lib/AST/FormatString.cpp

Optional<LengthModifier> FormatSpecifier::getCorrectedLengthModifier() const {
   }
 
   return None;
 }
 
 bool FormatSpecifier::namedTypeToLengthModifier(QualType QT,
                                                 LengthModifier &LM) {
   assert(isa<TypedefType>(QT) && "Expected a TypedefType");
-  const TypedefNameDecl *Typedef = cast<TypedefType>(QT)->getDecl();
+  const auto *TT = cast<TypedefType>(QT);
 
-  for (;;) {
-    const IdentifierInfo *Identifier = Typedef->getIdentifier();
+  do {
+    const IdentifierInfo *Identifier = TT->getDecl()->getIdentifier();
     if (Identifier->getName() == "size_t") {
       LM.setKind(LengthModifier::AsSizeT);
       return true;
     } else if (Identifier->getName() == "ssize_t") {
       // Not C99, but common in Unix.
       LM.setKind(LengthModifier::AsSizeT);
       return true;
     } else if (Identifier->getName() == "intmax_t") {
       LM.setKind(LengthModifier::AsIntMax);
       return true;
     } else if (Identifier->getName() == "uintmax_t") {
       LM.setKind(LengthModifier::AsIntMax);
       return true;
     } else if (Identifier->getName() == "ptrdiff_t") {
       LM.setKind(LengthModifier::AsPtrDiff);
       return true;
     }
-
-    QualType T = Typedef->getUnderlyingType();
-    if (!isa<TypedefType>(T))
-      break;
-
-    Typedef = cast<TypedefType>(T)->getDecl();
-  }
+  } while ((TT = TT->desugar()->getAs<TypedefType>()));
   return false;
 }

clang/lib/AST/JSONNodeDumper.cpp

JSONNodeDumper::createCXXBaseSpecifier(const CXXBaseSpecifier &BS) {
   if (BS.isPackExpansion())
     Ret["isPackExpansion"] = true;
 
   return Ret;
 }
 
 void JSONNodeDumper::VisitTypedefType(const TypedefType *TT) {
   JOS.attribute("decl", createBareDeclRef(TT->getDecl()));
+  if (TT->hasDifferentUnderlyingType())
+    JOS.attribute("type", createQualType(TT->desugar()));
 }
 
 void JSONNodeDumper::VisitFunctionType(const FunctionType *T) {
   FunctionType::ExtInfo E = T->getExtInfo();
   attributeOnlyIfTrue("noreturn", E.getNoReturn());
   attributeOnlyIfTrue("producesResult", E.getProducesResult());
   if (E.getHasRegParm())
     JOS.attribute("regParm", E.getRegParm());

clang/lib/AST/TextNodeDumper.cpp

 }
 
 void TextNodeDumper::VisitUnresolvedUsingType(const UnresolvedUsingType *T) {
   dumpDeclRef(T->getDecl());
 }
 
 void TextNodeDumper::VisitUsingType(const UsingType *T) {
   dumpDeclRef(T->getFoundDecl());
+  if (T->hasDifferentUnderlyingType())
+    OS << " resugared";
 }
 
 void TextNodeDumper::VisitTypedefType(const TypedefType *T) {
   dumpDeclRef(T->getDecl());
+  if (T->hasDifferentUnderlyingType())
+    OS << " resugared";
 }
 
 void TextNodeDumper::VisitUnaryTransformType(const UnaryTransformType *T) {
   switch (T->getUTTKind()) {
   case UnaryTransformType::EnumUnderlyingType:
     OS << " underlying_type";
     break;
   }

clang/lib/AST/Type.cpp

 
 void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID,
                                 const ASTContext &Ctx) {
   Profile(ID, getReturnType(), param_type_begin(), getNumParams(),
           getExtProtoInfo(), Ctx, isCanonicalUnqualified());
 }
 
 TypedefType::TypedefType(TypeClass tc, const TypedefNameDecl *D,
-                         QualType underlying, QualType can)
-    : Type(tc, can, toSemanticDependence(underlying->getDependence())),
+                         QualType Underlying, QualType can)
+    : Type(tc, can, toSemanticDependence(can->getDependence())),
       Decl(const_cast<TypedefNameDecl *>(D)) {
   assert(!isa<TypedefType>(can) && "Invalid canonical type");
+  TypedefBits.hasDifferentUnderlyingType = !Underlying.isNull();
+  if (hasDifferentUnderlyingType())
+    *reinterpret_cast<QualType *>(this + 1) = Underlying;
 }
 
 QualType TypedefType::desugar() const {
-  return getDecl()->getUnderlyingType();
+  return hasDifferentUnderlyingType()
+             ? *reinterpret_cast<const QualType *>(this + 1)
+             : Decl->getUnderlyingType();
 }
 
 UsingType::UsingType(const UsingShadowDecl *Found, QualType Underlying,
                      QualType Canon)
-    : Type(Using, Canon, toSemanticDependence(Underlying->getDependence())),
+    : Type(Using, Canon, toSemanticDependence(Canon->getDependence())),
       Found(const_cast<UsingShadowDecl *>(Found)) {
-  assert(Underlying == getUnderlyingType());
+  UsingBits.hasDifferentUnderlyingType = !Underlying.isNull();
+  if (hasDifferentUnderlyingType())
+    *reinterpret_cast<QualType *>(this + 1) = Underlying;
 }
 
 QualType UsingType::getUnderlyingType() const {
-  return QualType(cast<TypeDecl>(Found->getTargetDecl())->getTypeForDecl(), 0);
+  return hasDifferentUnderlyingType()
+             ? *reinterpret_cast<const QualType *>(this + 1)
+             : QualType(
+                   cast<TypeDecl>(Found->getTargetDecl())->getTypeForDecl(), 0);
 }
 
 QualType MacroQualifiedType::desugar() const { return getUnderlyingType(); }
 
 QualType MacroQualifiedType::getModifiedType() const {
   // Step over MacroQualifiedTypes from the same macro to find the type
   // ultimately qualified by the macro qualifier.
   QualType Inner = cast<AttributedType>(getUnderlyingType())->getModifiedType();

clang/lib/CodeGen/CGDebugInfo.cpp

llvm::DIType *CGDebugInfo::CreateType(const BlockPointerType *Ty,
   return DBuilder.createPointerType(EltTy, Size);
 }
 
 llvm::DIType *CGDebugInfo::CreateType(const TemplateSpecializationType *Ty,
                                       llvm::DIFile *Unit) {
   assert(Ty->isTypeAlias());
   llvm::DIType *Src = getOrCreateType(Ty->getAliasedType(), Unit);
 
-  auto *AliasDecl =
-      cast<TypeAliasTemplateDecl>(Ty->getTemplateName().getAsTemplateDecl())
-          ->getTemplatedDecl();
+  const TemplateDecl *TD = Ty->getTemplateName().getAsTemplateDecl();
+  if (isa<BuiltinTemplateDecl>(TD))
+    return Src;
 
+  const auto *AliasDecl = cast<TypeAliasTemplateDecl>(TD)->getTemplatedDecl();
   if (AliasDecl->hasAttr<NoDebugAttr>())
     return Src;
 
   SmallString<128> NS;
   llvm::raw_svector_ostream OS(NS);
   Ty->getTemplateName().print(OS, getPrintingPolicy(),
                               TemplateName::Qualified::None);
   printTemplateArgumentList(OS, Ty->template_arguments(), getPrintingPolicy());

clang/lib/Parse/ParseDecl.cpp

if (IsForRangeLoop) {
         VD->setObjCForDecl(true);
     }
     Actions.FinalizeDeclaration(ThisDecl);
     D.complete(ThisDecl);
     return Actions.FinalizeDeclaratorGroup(getCurScope(), DS, ThisDecl);
   }
 
   SmallVector<Decl *, 8> DeclsInGroup;
+  // FIXME: pump SS thorugh from DS.
   Decl *FirstDecl = ParseDeclarationAfterDeclaratorAndAttributes(
       D, ParsedTemplateInfo(), FRI);
   if (LateParsedAttrs.size() > 0)
     ParseLexedAttributeList(LateParsedAttrs, FirstDecl, true, false);
   D.complete(FirstDecl);
   if (FirstDecl)
     DeclsInGroup.push_back(FirstDecl);
 
if (Tok.is(tok::kw_delete)) {
         SmallVector<tok::TokenKind, 2> StopTokens;
         StopTokens.push_back(tok::comma);
         if (D.getContext() == DeclaratorContext::ForInit ||
             D.getContext() == DeclaratorContext::SelectionInit)
           StopTokens.push_back(tok::r_paren);
         SkipUntil(StopTokens, StopAtSemi | StopBeforeMatch);
         Actions.ActOnInitializerError(ThisDecl);
       } else
+        // FIXME: pump SS through
         Actions.AddInitializerToDecl(ThisDecl, Init.get(),
                                      /*DirectInit=*/false);
     }
     break;
   }
   case InitKind::CXXDirect: {
     // Parse C++ direct initializer: '(' expression-list ')'
     BalancedDelimiterTracker T(*this, tok::l_paren);

clang/lib/Sema/SemaCXXScopeSpec.cpp

if (AcceptSpec) {
 
     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()));
+    T = resugar(SS, /*NamedDecl=*/nullptr, /*Args=*/nullptr, T);
 
     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, /*NamedDecl=*/nullptr, /*Args=*/nullptr, 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
bool Sema::ActOnCXXNestedNameSpecifier(Scope *S,
   TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
   translateTemplateArguments(TemplateArgsIn, TemplateArgs);
 
   DependentTemplateName *DTN = Template.getAsDependentTemplateName();
   if (DTN && DTN->isIdentifier()) {
     // Handle a dependent template specialization for which we cannot resolve
     // the template name.
     assert(DTN->getQualifier() == SS.getScopeRep());
+    resugarTemplateArguments(SS, TemplateArgs);
     QualType T = Context.getDependentTemplateSpecializationType(ETK_None,
                                                           DTN->getQualifier(),
                                                           DTN->getIdentifier(),
                                                                 TemplateArgs);
 
     // Create source-location information for this type.
     TypeLocBuilder Builder;
     DependentTemplateSpecializationTypeLoc SpecTL
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/SemaCast.cpp

FunctionDecl *Fn = Self.ResolveAddressOfOverloadedFunction(SrcExpr.get(),
                                                                DestType,
                                                                true,
                                                                FoundOverload);
     if (!Fn) {
       msg = 0;
       return TC_Failed;
     }
 
-    SrcExpr = Self.FixOverloadedFunctionReference(SrcExpr, FoundOverload, Fn);
+    // FIXME: resugar
+    SrcExpr = Self.FixOverloadedFunctionReference(SrcExpr, FoundOverload, Fn,
+                                                  nullptr);
     if (!SrcExpr.isUsable()) {
       msg = 0;
       return TC_Failed;
     }
   }
 
   Self.BuildBasePathArray(Paths, BasePath);
   Kind = CK_DerivedToBaseMemberPointer;
if (Self.getASTContext().isDependenceAllowed() &&
     return;
   }
 
   // Overloads are allowed with C extensions, so we need to support them.
   if (SrcExpr.get()->getType() == Self.Context.OverloadTy) {
     DeclAccessPair DAP;
     if (FunctionDecl *FD = Self.ResolveAddressOfOverloadedFunction(
             SrcExpr.get(), DestType, /*Complain=*/true, DAP))
-      SrcExpr = Self.FixOverloadedFunctionReference(SrcExpr.get(), DAP, FD);
+      // FIXME: resugar
+      SrcExpr =
+          Self.FixOverloadedFunctionReference(SrcExpr.get(), DAP, FD, nullptr);
     else
       return;
     assert(SrcExpr.isUsable());
   }
   SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
   if (SrcExpr.isInvalid())
     return;
   QualType SrcType = SrcExpr.get()->getType();

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)
               : S.BuildFieldReferenceExpr(
                     RecordArg, RecordArgIsPtr, Loc, CXXScopeSpec(), FD,
-                    DeclAccessPair::make(FD, AS_public),
+                    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);
+    T = resugar(SS && SS->isValid() ? *SS : CXXScopeSpec(), TD,
+                /*Args=*/nullptr, 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);
if (getLangOpts().DebuggerCastResultToId &&
     DefaultedAnyToId = true;
   }
 
   // C++ [dcl.decomp]p1:
   //   If the assignment-expression [...] has array type A and no ref-qualifier
   //   is present, e has type cv A
   if (VDecl && isa<DecompositionDecl>(VDecl) &&
       Context.hasSameUnqualifiedType(Type, Context.getAutoDeductType()) &&
-      DeduceInit->getType()->isConstantArrayType())
-    return Context.getQualifiedType(DeduceInit->getType(),
-                                    Type.getQualifiers());
+      DeduceInit->getType()->isConstantArrayType()) {
+    QualType T = DeduceInit->getType();
+    // Remove any substitution sugar.
+    T = resugarEscapes(T);
+    return Context.getQualifiedType(T, Type.getQualifiers());
+  }
 
   QualType DeducedType;
   if (DeduceAutoType(TSI, DeduceInit, DeducedType) == DAR_Failed) {
     if (!IsInitCapture)
       DiagnoseAutoDeductionFailure(VDecl, DeduceInit);
     else if (isa<InitListExpr>(Init))
       Diag(Range.getBegin(),
            diag::err_init_capture_deduction_failure_from_init_list)
if (CXXDirectInit) {
     // This must be list-initialization. No other way is direct-initialization.
     VDecl->setInitStyle(VarDecl::ListInit);
   }
 
   if (LangOpts.OpenMP &&
       (LangOpts.OpenMPIsDevice || !LangOpts.OMPTargetTriples.empty()) &&
       VDecl->isFileVarDecl())
     DeclsToCheckForDeferredDiags.insert(VDecl);
+  // FIXME: wire SS through
   CheckCompleteVariableDeclaration(VDecl);
 }
 
 /// ActOnInitializerError - Given that there was an error parsing an
 /// initializer for the given declaration, try to at least re-establish
 /// invariants such as whether a variable's type is either dependent or
 /// complete.
 void Sema::ActOnInitializerError(Decl *D) {
void Sema::CheckCompleteVariableDeclaration(VarDecl *var) {
 
   // If this variable must be emitted, add it as an initializer for the current
   // module.
   if (Context.DeclMustBeEmitted(var) && !ModuleScopes.empty())
     Context.addModuleInitializer(ModuleScopes.back().Module, var);
 
   // Build the bindings if this is a structured binding declaration.
   if (auto *DD = dyn_cast<DecompositionDecl>(var))
+    // FIXME: wire SS through
     CheckCompleteDecompositionDeclaration(DD);
 }
 
 /// Check if VD needs to be dllexport/dllimport due to being in a
 /// dllexport/import function.
 void Sema::CheckStaticLocalForDllExport(VarDecl *VD) {
   assert(VD->isStaticLocal());
 

clang/lib/Sema/SemaDeclAttr.cpp

if (auto *DRE = dyn_cast<DeclRefExpr>(E)) {
     FD = dyn_cast<FunctionDecl>(DRE->getDecl());
     NI = DRE->getNameInfo();
     if (!FD) {
       S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 1
         << NI.getName();
       return;
     }
   } else if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
-    if (ULE->hasExplicitTemplateArgs())
+    if (ULE->hasExplicitTemplateArgs()) {
       S.Diag(Loc, diag::warn_cleanup_ext);
-    FD = S.ResolveSingleFunctionTemplateSpecialization(ULE, true);
+      TemplateArgumentListInfo ExplicitTemplateArgs;
+      ULE->copyTemplateArgumentsInto(ExplicitTemplateArgs);
+      FD = S.ResolveSingleFunctionTemplateSpecialization(
+          ULE, ExplicitTemplateArgs, /*Complain=*/true);
+    }
     NI = ULE->getNameInfo();
     if (!FD) {
       S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 2
         << NI.getName();
       if (ULE->getType() == S.Context.OverloadTy)
         S.NoteAllOverloadCandidates(ULE);
       return;
     }
   } else {
     S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 0;
     return;
   }
 
   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: get SS
+    QualType FieldType = FD->getType();
+    FieldType =
+        S.resugar(CXXScopeSpec(), FD, nullptr, FieldType, /*Escapes=*/true);
+
     // 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,
+                                  CXXScopeSpec(), 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;
 }
 
Diag(DD->getLocation(), diag::err_decomp_decl_unbindable_type)
         << DD << !RD << DecompType;
     DD->setInvalidDecl();
     return;
   }
 
   // C++1z [dcl.decomp]/4:
   //   all of E's non-static data members shall be [...] direct members of
   //   E or of the same unambiguous public base class of E, ...
+  // FIXME: wire SS through
   if (checkMemberDecomposition(*this, Bindings, DD, DecompType, RD))
     DD->setInvalidDecl();
 }
 
 /// Merge the exception specifications of two variable declarations.
 ///
 /// This is called when there's a redeclaration of a VarDecl. The function
 /// checks if the redeclaration might have an exception specification and
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),
+                                      CXXScopeSpec(), Field, FieldType, Found,
+                                      NameInfo),
             S.BuildFieldReferenceExpr(Obj.second.get(), /*IsArrow=*/false, Loc,
-                                      CXXScopeSpec(), Field, Found, NameInfo)};
+                                      CXXScopeSpec(), 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();
if (!StdInitializerList) {
     if (!StdInitializerList)
       return QualType();
   }
 
   TemplateArgumentListInfo Args(Loc, Loc);
   Args.addArgument(TemplateArgumentLoc(TemplateArgument(Element),
                                        Context.getTrivialTypeSourceInfo(Element,
                                                                         Loc)));
-  return Context.getCanonicalType(
-      CheckTemplateIdType(TemplateName(StdInitializerList), Loc, Args));
+  return Context.getCanonicalType(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(
   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();
+  // A DeclRefExpr captures everything needed to make sense
+  // of the substitution sugar, so it's not correct to say
+  // that it would be escaping into it, however there is
+  // seemingly no use for it, and it would be more annoying
+  // to deal with it later.
+  type = resugar(SS, VD, TemplateArgs, type, /*Escapes=*/true);
   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()) {
if (BD->getDeclContext() != CurContext) {
       auto *DD = dyn_cast_or_null<VarDecl>(BD->getDecomposedDecl());
       if (DD && DD->hasLocalStorage())
         diagnoseUncapturableValueReference(*this, Loc, BD);
     }
     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 (getLangOpts().CPlusPlus) {
     // FIXME: We also fall through for atomics; not sure what should
     // happen there, though.
   } else if (RHS.get()->getType() == Context.OverloadTy) {
     // As a set of extensions to C, we support overloading on functions. These
     // functions need to be resolved here.
     DeclAccessPair DAP;
     if (FunctionDecl *FD = ResolveAddressOfOverloadedFunction(
             RHS.get(), LHSType, /*Complain=*/false, DAP))
-      RHS = FixOverloadedFunctionReference(RHS.get(), DAP, FD);
+      // FIXME: resugar
+      RHS = FixOverloadedFunctionReference(RHS.get(), DAP, FD, nullptr);
     else
       return Incompatible;
   }
 
   // C99 6.5.16.1p1: the left operand is a pointer and the right is
   // a null pointer constant.
   if ((LHSType->isPointerType() || LHSType->isObjCObjectPointerType() ||
        LHSType->isBlockPointerType()) &&
if (PTy->getKind() == BuiltinType::Overload) {
       if (!isa<OverloadExpr>(E)) {
         assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf);
         Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof_addrof_function)
           << OrigOp.get()->getSourceRange();
         return QualType();
       }
 
       OverloadExpr *Ovl = cast<OverloadExpr>(E);
-      if (isa<UnresolvedMemberExpr>(Ovl))
-        if (!ResolveSingleFunctionTemplateSpecialization(Ovl)) {
-          Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
-            << OrigOp.get()->getSourceRange();
-          return QualType();
-        }
+      if (!isa<UnresolvedMemberExpr>(Ovl))
+        return Context.OverloadTy;
+      if (Ovl->hasExplicitTemplateArgs()) {
+        TemplateArgumentListInfo ExplicitTemplateArgs;
+        Ovl->copyTemplateArgumentsInto(ExplicitTemplateArgs);
+        if (ResolveSingleFunctionTemplateSpecialization(Ovl,
+                                                        ExplicitTemplateArgs))
+          return Context.OverloadTy;
+      }
 
-      return Context.OverloadTy;
-    }
-
     if (PTy->getKind() == BuiltinType::UnknownAny)
       return Context.UnknownAnyTy;
 
     if (PTy->getKind() == BuiltinType::BoundMember) {
       Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
         << OrigOp.get()->getSourceRange();
       return QualType();
     }
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);
       }
     }
 

clang/lib/Sema/SemaExprCXX.cpp

if (Context.hasSameType(FromType, Context.OverloadTy)) {
     FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType,
                                                           true, Found);
     if (!Fn)
       return ExprError();
 
     if (DiagnoseUseOfDecl(Fn, From->getBeginLoc()))
       return ExprError();
 
-    From = FixOverloadedFunctionReference(From, Found, Fn);
+    // FIXME: resugar
+    From = FixOverloadedFunctionReference(From, Found, Fn, nullptr);
 
     // We might get back another placeholder expression if we resolved to a
     // builtin.
     ExprResult Checked = CheckPlaceholderExpr(From);
     if (Checked.isInvalid())
       return ExprError();
 
     From = Checked.get();

clang/lib/Sema/SemaExprMember.cpp

Sema::BuildAnonymousStructUnionMemberReference(const CXXScopeSpec &SS,
   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);
 
+    QualType FieldType = field->getType();
+    FieldType = resugar(SS, field, nullptr, FieldType, /*Escapes=*/true);
+
     // Build the first member access in the chain with full information.
     result =
         BuildFieldReferenceExpr(result, baseObjectIsPointer, SourceLocation(),
-                                SS, field, foundDecl, memberNameInfo)
+                                SS, 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());
 
+    // FIXME: duplication above. Also, is SS right here?
+    QualType FieldType = field->getType();
+    FieldType = resugar(SS, field, nullptr, FieldType, /*Escapes=*/true);
+
     result =
         BuildFieldReferenceExpr(result, /*isarrow*/ false, SourceLocation(),
-                                (FI == FEnd ? SS : EmptySS), field,
+                                (FI == FEnd ? SS : EmptySS), field, FieldType,
                                 fakeFoundDecl, memberNameInfo)
             .get();
   }
 
   return result;
 }
 
 static ExprResult
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)) {
+    QualType FieldType = FD->getType();
+    // FIXME: Extend SS here with BaseType?
+    FieldType = resugar(SS, FD, TemplateArgs, FieldType, /*Escapes=*/true);
+    // FIXME: these should take in BaseType as well, because BaseExpr might be
+    // null
+    //        in case of implicit access.
+    return BuildFieldReferenceExpr(BaseExpr, IsArrow, OpLoc, SS, 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);
 
   if (VarDecl *Var = dyn_cast<VarDecl>(MemberDecl)) {
+    QualType VarType = Var->getType();
+    VarType = resugar(SS, Var, TemplateArgs, VarType, /*Escapes=*/true);
     return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Var,
                            FoundDecl, /*HadMultipleCandidates=*/false,
-                           MemberNameInfo, Var->getType().getNonReferenceType(),
+                           MemberNameInfo, VarType.getNonReferenceType(),
                            VK_LValue, OK_Ordinary);
   }
 
   if (CXXMethodDecl *MemberFn = dyn_cast<CXXMethodDecl>(MemberDecl)) {
     ExprValueKind valueKind;
     QualType type;
     if (MemberFn->isInstance()) {
       valueKind = VK_PRValue;
       type = Context.BoundMemberTy;
     } else {
       valueKind = VK_LValue;
       type = MemberFn->getType();
+      type = resugar(SS, MemberFn, TemplateArgs, type, /*Escapes=*/true);
     }
 
     return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, 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)) {
+    QualType EnumType = Enum->getType();
+    EnumType = resugar(SS, Enum, TemplateArgs, EnumType, /*Escapes=*/true);
     return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Enum,
                            FoundDecl, /*HadMultipleCandidates=*/false,
                            MemberNameInfo, Enum->getType(), VK_PRValue,
                            OK_Ordinary);
   }
 
   if (VarTemplateDecl *VarTempl = dyn_cast<VarTemplateDecl>(MemberDecl)) {
     if (!TemplateArgs) {
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);
 
+    QualType VarType = Var->getType();
+    VarType = resugar(SS, Var, TemplateArgs, VarType, /*Escapes=*/true);
+
     return BuildMemberExpr(
         BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Var, FoundDecl,
         /*HadMultipleCandidates=*/false, MemberNameInfo,
-        Var->getType().getNonReferenceType(), VK_LValue, OK_Ordinary);
+        VarType.getNonReferenceType(), VK_LValue, OK_Ordinary);
   }
 
   // We found something that we didn't expect. Complain.
   if (isa<TypeDecl>(MemberDecl))
     Diag(MemberLoc, diag::err_typecheck_member_reference_type)
       << MemberName << BaseType << int(IsArrow);
   else
     Diag(MemberLoc, diag::err_typecheck_member_reference_unknown)
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 CXXScopeSpec &SS,
+    FieldDecl *Field, QualType FieldType, DeclAccessPair FoundDecl,
   // 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);
if (auto *PrivateCopy = isOpenMPCapturedDecl(Field)) {
       return getOpenMPCapturedExpr(PrivateCopy, VK, OK,
                                    MemberNameInfo.getLoc());
     }
   }
 
   return BuildMemberExpr(Base.get(), IsArrow, OpLoc, &SS,
                          /*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

for (step_iterator Step = step_begin(), StepEnd = step_end();
 
     switch (Step->Kind) {
     case SK_ResolveAddressOfOverloadedFunction:
       // Overload resolution determined which function invoke; update the
       // initializer to reflect that choice.
       S.CheckAddressOfMemberAccess(CurInit.get(), Step->Function.FoundDecl);
       if (S.DiagnoseUseOfDecl(Step->Function.FoundDecl, Kind.getLocation()))
         return ExprError();
-      CurInit = S.FixOverloadedFunctionReference(CurInit,
-                                                 Step->Function.FoundDecl,
-                                                 Step->Function.Function);
+      // FIXME: resugar
+      CurInit = S.FixOverloadedFunctionReference(
+          CurInit, Step->Function.FoundDecl, Step->Function.Function, nullptr);
       // We might get back another placeholder expression if we resolved to a
       // builtin.
       if (!CurInit.isInvalid())
         CurInit = S.CheckPlaceholderExpr(CurInit.get());
       break;
 
     case SK_CastDerivedToBasePRValue:
     case SK_CastDerivedToBaseXValue:

 
 QualType Sema::DeduceTemplateSpecializationFromInitializer(
     TypeSourceInfo *TSInfo, const InitializedEntity &Entity,
     const InitializationKind &Kind, MultiExprArg Inits) {
   auto *DeducedTST = dyn_cast<DeducedTemplateSpecializationType>(
       TSInfo->getType()->getContainedDeducedType());
   assert(DeducedTST && "not a deduced template specialization type");
 
+  MultiExprArg OrigInits = Inits;
+
   auto TemplateName = DeducedTST->getTemplateName();
   if (TemplateName.isDependent())
     return SubstAutoTypeDependent(TSInfo->getType());
 
   // We can only perform deduction for class templates.
   auto *Template =
       dyn_cast_or_null<ClassTemplateDecl>(TemplateName.getAsTemplateDecl());
   if (!Template) {
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 these
+  RT = resugar(CXXScopeSpec(), Best->Function, nullptr, RT, /*Escapes=*/true);
 
   // 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/SemaLookup.cpp

if (FunctionTemplateDecl *FD = dyn_cast<FunctionTemplateDecl>(D)) {
 
         // A string literal template is only considered if the string literal
         // is a well-formed template argument for the template parameter.
         if (StringLit) {
           SFINAETrap Trap(*this);
           SmallVector<TemplateArgument, 1> Checked;
           TemplateArgumentLoc Arg(TemplateArgument(StringLit), StringLit);
           if (CheckTemplateArgument(Params->getParam(0), Arg, FD,
-                                    R.getNameLoc(), R.getNameLoc(), 0,
-                                    Checked) ||
+                                    R.getNameLoc(), R.getNameLoc(), 0, Checked,
+                                    CTAK_Specified,
+                                    /*DontCanonicalize=*/true) ||
               Trap.hasErrorOccurred())
             IsTemplate = false;
         }
       } else {
         IsStringTemplatePack = true;
       }
     }
 

clang/lib/Sema/SemaOverload.cpp

 /// CheckConvertedConstantExpression - Check that the expression From is a
 /// converted constant expression of type T, perform the conversion and produce
 /// the converted expression, per C++11 [expr.const]p3.
 static ExprResult CheckConvertedConstantExpression(Sema &S, Expr *From,
                                                    QualType T, APValue &Value,
                                                    Sema::CCEKind CCE,
                                                    bool RequireInt,
                                                    NamedDecl *Dest) {
-  assert(S.getLangOpts().CPlusPlus11 &&
-         "converted constant expression outside C++11");
-
   if (checkPlaceholderForOverload(S, From))
     return ExprError();
 
   // C++1z [expr.const]p3:
   //  A converted constant expression of type T is an expression,
   //  implicitly converted to type T, where the converted
   //  expression is a constant expression and the implicit conversion
   //  sequence contains only [... list of conversions ...].

 /// \param PartialOverloading true if we are performing "partial" overloading
 /// based on an incomplete set of function arguments. This feature is used by
 /// code completion.
 void Sema::AddOverloadCandidate(
     FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef<Expr *> Args,
     OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
     bool PartialOverloading, bool AllowExplicit, bool AllowExplicitConversions,
     ADLCallKind IsADLCandidate, ConversionSequenceList EarlyConversions,
-    OverloadCandidateParamOrder PO) {
+    OverloadCandidateParamOrder PO, const TemplateArgumentList *Deduced) {
   const FunctionProtoType *Proto
     = dyn_cast<FunctionProtoType>(Function->getType()->getAs<FunctionType>());
   assert(Proto && "Functions without a prototype cannot be overloaded");
   assert(!Function->getDescribedFunctionTemplate() &&
          "Use AddTemplateOverloadCandidate for function templates");
 
   if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
     if (!isa<CXXConstructorDecl>(Method)) {
       // If we get here, it's because we're calling a member function
       // that is named without a member access expression (e.g.,
       // "this->f") that was either written explicitly or created
       // implicitly. This can happen with a qualified call to a member
       // function, e.g., X::f(). We use an empty type for the implied
       // object argument (C++ [over.call.func]p3), and the acting context
       // is irrelevant.
       AddMethodCandidate(Method, FoundDecl, Method->getParent(), QualType(),
                          Expr::Classification::makeSimpleLValue(), Args,
                          CandidateSet, SuppressUserConversions,
-                         PartialOverloading, EarlyConversions, PO);
+                         PartialOverloading, EarlyConversions, PO, Deduced);
       return;
     }
     // We treat a constructor like a non-member function, since its object
     // argument doesn't participate in overload resolution.
   }
 
   if (!CandidateSet.isNewCandidate(Function, PO))
     return;
void Sema::AddOverloadCandidate(
   Candidate.Function = Function;
   Candidate.Viable = true;
   Candidate.RewriteKind =
       CandidateSet.getRewriteInfo().getRewriteKind(Function, PO);
   Candidate.IsSurrogate = false;
   Candidate.IsADLCandidate = IsADLCandidate;
   Candidate.IgnoreObjectArgument = false;
   Candidate.ExplicitCallArguments = Args.size();
+  Candidate.Deduced = Deduced;
 
   // Explicit functions are not actually candidates at all if we're not
   // allowing them in this context, but keep them around so we can point
   // to them in diagnostics.
   if (!AllowExplicit && ExplicitSpecifier::getFromDecl(Function).isExplicit()) {
     Candidate.Viable = false;
     Candidate.FailureKind = ovl_fail_explicit;
     return;

 
 /// AddMethodCandidate - Adds the given C++ member function to the set
 /// of candidate functions, using the given function call arguments
 /// and the object argument (@c Object). For example, in a call
 /// @c o.f(a1,a2), @c Object will contain @c o and @c Args will contain
 /// both @c a1 and @c a2. If @p SuppressUserConversions, then don't
 /// allow user-defined conversions via constructors or conversion
 /// operators.
-void
-Sema::AddMethodCandidate(CXXMethodDecl *Method, DeclAccessPair FoundDecl,
-                         CXXRecordDecl *ActingContext, QualType ObjectType,
-                         Expr::Classification ObjectClassification,
-                         ArrayRef<Expr *> Args,
-                         OverloadCandidateSet &CandidateSet,
-                         bool SuppressUserConversions,
-                         bool PartialOverloading,
-                         ConversionSequenceList EarlyConversions,
-                         OverloadCandidateParamOrder PO) {
+void Sema::AddMethodCandidate(
+    CXXMethodDecl *Method, DeclAccessPair FoundDecl,
+    Expr::Classification ObjectClassification, ArrayRef<Expr *> Args,
+    OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
+    bool PartialOverloading, ConversionSequenceList EarlyConversions,
+    OverloadCandidateParamOrder PO, const TemplateArgumentList *Deduced) {
   const FunctionProtoType *Proto
     = dyn_cast<FunctionProtoType>(Method->getType()->getAs<FunctionType>());
   assert(Proto && "Methods without a prototype cannot be overloaded");
   assert(!isa<CXXConstructorDecl>(Method) &&
          "Use AddOverloadCandidate for constructors");
 
   if (!CandidateSet.isNewCandidate(Method, PO))
     return;
OverloadCandidate &Candidate =
       CandidateSet.addCandidate(Args.size() + 1, EarlyConversions);
   Candidate.FoundDecl = FoundDecl;
   Candidate.Function = Method;
   Candidate.RewriteKind =
       CandidateSet.getRewriteInfo().getRewriteKind(Method, PO);
   Candidate.IsSurrogate = false;
   Candidate.IgnoreObjectArgument = false;
   Candidate.ExplicitCallArguments = Args.size();
+  Candidate.Deduced = Deduced;
 
   unsigned NumParams = Proto->getNumParams();
 
   // (C++ 13.3.2p2): A candidate function having fewer than m
   // parameters is viable only if it has an ellipsis in its parameter
   // list (8.3.5).
   if (TooManyArguments(NumParams, Args.size(), PartialOverloading) &&
       !Proto->isVariadic() &&
void Sema::AddMethodTemplateCandidate(
   // Add the function template specialization produced by template argument
   // deduction as a candidate.
   assert(Specialization && "Missing member function template specialization?");
   assert(isa<CXXMethodDecl>(Specialization) &&
          "Specialization is not a member function?");
   AddMethodCandidate(cast<CXXMethodDecl>(Specialization), FoundDecl,
                      ActingContext, ObjectType, ObjectClassification, Args,
                      CandidateSet, SuppressUserConversions, PartialOverloading,
-                     Conversions, PO);
+                     Conversions, PO, Info.take());
 }
 
 /// Determine whether a given function template has a simple explicit specifier
 /// or a non-value-dependent explicit-specification that evaluates to true.
 static bool isNonDependentlyExplicit(FunctionTemplateDecl *FTD) {
   return ExplicitSpecifier::getFromDecl(FTD->getTemplatedDecl()).isExplicit();
 }
 
else {
                                                             Info);
     }
     return;
   }
 
   // Add the function template specialization produced by template argument
   // deduction as a candidate.
   assert(Specialization && "Missing function template specialization?");
-  AddOverloadCandidate(
-      Specialization, FoundDecl, Args, CandidateSet, SuppressUserConversions,
-      PartialOverloading, AllowExplicit,
-      /*AllowExplicitConversions*/ false, IsADLCandidate, Conversions, PO);
+  AddOverloadCandidate(Specialization, FoundDecl, Args, CandidateSet,
+                       SuppressUserConversions, PartialOverloading,
+                       AllowExplicit,
+                       /*AllowExplicitConversions*/ false, IsADLCandidate,
+                       Conversions, PO, Info.take());
 }
 
 /// Check that implicit conversion sequences can be formed for each argument
 /// whose corresponding parameter has a non-dependent type, per DR1391's
 /// [temp.deduct.call]p10.
 bool Sema::CheckNonDependentConversions(
     FunctionTemplateDecl *FunctionTemplate, ArrayRef<QualType> ParamTypes,
     ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet,
AddressOfFunctionResolver(Sema &S, Expr *SourceExpr,
         FoundNonTemplateFunction(false),
         StaticMemberFunctionFromBoundPointer(false),
         HasComplained(false),
         OvlExprInfo(OverloadExpr::find(SourceExpr)),
         OvlExpr(OvlExprInfo.Expression),
         FailedCandidates(OvlExpr->getNameLoc(), /*ForTakingAddress=*/true) {
     ExtractUnqualifiedFunctionTypeFromTargetType();
 
+    if (OvlExpr->hasExplicitTemplateArgs())
+      OvlExpr->copyTemplateArgumentsInto(OvlExplicitTemplateArgs);
+
     if (TargetFunctionType->isFunctionType()) {
       if (UnresolvedMemberExpr *UME = dyn_cast<UnresolvedMemberExpr>(OvlExpr))
         if (!UME->isImplicitAccess() &&
-            !S.ResolveSingleFunctionTemplateSpecialization(UME))
+            (!OvlExpr->hasExplicitTemplateArgs() ||
+             !S.ResolveSingleFunctionTemplateSpecialization(
+                 UME, OvlExplicitTemplateArgs)))
           StaticMemberFunctionFromBoundPointer = true;
     } else if (OvlExpr->hasExplicitTemplateArgs()) {
       DeclAccessPair dap;
       if (FunctionDecl *Fn = S.ResolveSingleFunctionTemplateSpecialization(
-              OvlExpr, false, &dap)) {
+              OvlExpr, OvlExplicitTemplateArgs, /*Complain=*/false, &dap)) {
         if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn))
           if (!Method->isStatic()) {
             // If the target type is a non-function type and the function found
             // is a non-static member function, pretend as if that was the
             // target, it's the only possible type to end up with.
             TargetTypeIsNonStaticMemberFunction = true;
 
             // And skip adding the function if its not in the proper form.
             // We'll diagnose this due to an empty set of functions.
             if (!OvlExprInfo.HasFormOfMemberPointer)
               return;
           }
 
         Matches.push_back(std::make_pair(dap, Fn));
       }
       return;
     }
 
-    if (OvlExpr->hasExplicitTemplateArgs())
-      OvlExpr->copyTemplateArgumentsInto(OvlExplicitTemplateArgs);
-
     if (FindAllFunctionsThatMatchTargetTypeExactly()) {
       // C++ [over.over]p4:
       //   If more than one function is selected, [...]
       if (Matches.size() > 1 && !eliminiateSuboptimalOverloadCandidates()) {
         if (FoundNonTemplateFunction)
           EliminateAllTemplateMatches();
         else
           EliminateAllExceptMostSpecializedTemplate();
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);
-  Expr *Fixed = FixOverloadedFunctionReference(E, DAP, Found);
+  // FIXME: resugar
+  Expr *Fixed = FixOverloadedFunctionReference(E, DAP, Found, nullptr);
   if (DoFunctionPointerConverion && Fixed->getType()->isFunctionType())
     SrcExpr = DefaultFunctionArrayConversion(Fixed, /*Diagnose=*/false);
   else
     SrcExpr = Fixed;
   return true;
 }
 
 /// Given an expression that refers to an overloaded function, try to
 /// resolve that overloaded function expression down to a single function.
 ///
 /// This routine can only resolve template-ids that refer to a single function
 /// template, where that template-id refers to a single template whose template
 /// arguments are either provided by the template-id or have defaults,
 /// as described in C++0x [temp.arg.explicit]p3.
 ///
 /// If no template-ids are found, no diagnostics are emitted and NULL is
 /// returned.
-FunctionDecl *
-Sema::ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl,
-                                                  bool Complain,
-                                                  DeclAccessPair *FoundResult) {
+FunctionDecl *Sema::ResolveSingleFunctionTemplateSpecialization(
+    OverloadExpr *ovl, TemplateArgumentListInfo &ExplicitTemplateArgs,
+    bool Complain, DeclAccessPair *FoundResult) {
   // C++ [over.over]p1:
   //   [...] [Note: any redundant set of parentheses surrounding the
   //   overloaded function name is ignored (5.1). ]
   // C++ [over.over]p1:
   //   [...] The overloaded function name can be preceded by the &
   //   operator.
 
-  // If we didn't actually find any template-ids, we're done.
-  if (!ovl->hasExplicitTemplateArgs())
-    return nullptr;
+  // Specializations must have template args.
+  assert(ovl->hasExplicitTemplateArgs());
 
-  TemplateArgumentListInfo ExplicitTemplateArgs;
-  ovl->copyTemplateArgumentsInto(ExplicitTemplateArgs);
   TemplateSpecCandidateSet FailedCandidates(ovl->getNameLoc());
 
   // Look through all of the overloaded functions, searching for one
   // whose type matches exactly.
   FunctionDecl *Matched = nullptr;
   for (UnresolvedSetIterator I = ovl->decls_begin(),
          E = ovl->decls_end(); I != E; ++I) {
     // C++0x [temp.arg.explicit]p3:

 bool Sema::ResolveAndFixSingleFunctionTemplateSpecialization(
                       ExprResult &SrcExpr, bool doFunctionPointerConverion,
                       bool complain, SourceRange OpRangeForComplaining,
                                            QualType DestTypeForComplaining,
                                             unsigned DiagIDForComplaining) {
   assert(SrcExpr.get()->getType() == Context.OverloadTy);
 
   OverloadExpr::FindResult ovl = OverloadExpr::find(SrcExpr.get());
+  ExprResult SingleFunctionExpression;
+  if (ovl.Expression->hasExplicitTemplateArgs()) {
+    TemplateArgumentListInfo ExplicitTemplateArgs;
+    ovl.Expression->copyTemplateArgumentsInto(ExplicitTemplateArgs);
 
     DeclAccessPair found;
-  ExprResult SingleFunctionExpression;
     if (FunctionDecl *fn = ResolveSingleFunctionTemplateSpecialization(
-                           ovl.Expression, /*complain*/ false, &found)) {
+            ovl.Expression, ExplicitTemplateArgs, /*Complain=*/false, &found)) {
       if (DiagnoseUseOfDecl(fn, SrcExpr.get()->getBeginLoc())) {
         SrcExpr = ExprError();
         return true;
       }
 
       // It is only correct to resolve to an instance method if we're
       // resolving a form that's permitted to be a pointer to member.
       // Otherwise we'll end up making a bound member expression, which
       // is illegal in all the contexts we resolve like this.
-    if (!ovl.HasFormOfMemberPointer &&
-        isa<CXXMethodDecl>(fn) &&
+      if (!ovl.HasFormOfMemberPointer && isa<CXXMethodDecl>(fn) &&
           cast<CXXMethodDecl>(fn)->isInstance()) {
-      if (!complain) return false;
+        if (!complain)
+          return false;
 
-      Diag(ovl.Expression->getExprLoc(),
-           diag::err_bound_member_function)
+        Diag(ovl.Expression->getExprLoc(), diag::err_bound_member_function)
             << 0 << ovl.Expression->getSourceRange();
 
         // TODO: I believe we only end up here if there's a mix of
         // static and non-static candidates (otherwise the expression
         // would have 'bound member' type, not 'overload' type).
         // Ideally we would note which candidate was chosen and why
         // the static candidates were rejected.
         SrcExpr = ExprError();
         return true;
       }
 
       // Fix the expression to refer to 'fn'.
+      // FIXME: resugar
       SingleFunctionExpression =
-        FixOverloadedFunctionReference(SrcExpr.get(), found, fn);
+          FixOverloadedFunctionReference(SrcExpr.get(), found, fn, nullptr);
 
       // If desired, do function-to-pointer decay.
       if (doFunctionPointerConverion) {
-      SingleFunctionExpression =
-        DefaultFunctionArrayLvalueConversion(SingleFunctionExpression.get());
+        SingleFunctionExpression = DefaultFunctionArrayLvalueConversion(
+            SingleFunctionExpression.get());
         if (SingleFunctionExpression.isInvalid()) {
           SrcExpr = ExprError();
           return true;
         }
       }
     }
+  }
 
   if (!SingleFunctionExpression.isUsable()) {
     if (complain) {
       Diag(OpRangeForComplaining.getBegin(), DiagIDForComplaining)
         << ovl.Expression->getName()
         << DestTypeForComplaining
         << OpRangeForComplaining
         << ovl.Expression->getQualifierLoc().getSourceRange();
static ExprResult FinishOverloadedCallExpr(Sema &SemaRef, Scope *S, Expr *Fn,
                                            OverloadingResult OverloadResult,
                                            bool AllowTypoCorrection) {
   switch (OverloadResult) {
   case OR_Success: {
     FunctionDecl *FDecl = (*Best)->Function;
     SemaRef.CheckUnresolvedLookupAccess(ULE, (*Best)->FoundDecl);
     if (SemaRef.DiagnoseUseOfDecl(FDecl, ULE->getNameLoc()))
       return ExprError();
-    Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
+    Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl,
+                                                (*Best)->Deduced);
     return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc,
                                          ExecConfig, /*IsExecConfig=*/false,
                                          (*Best)->IsADLCandidate);
   }
 
   case OR_No_Viable_Function: {
     // Try to recover by looking for viable functions which the user might
     // have meant to call.
CandidateSet->NoteCandidates(
         PartialDiagnosticAt(Fn->getBeginLoc(),
                             SemaRef.PDiag(diag::err_ovl_deleted_call)
                                 << ULE->getName() << Fn->getSourceRange()),
         SemaRef, OCD_AllCandidates, Args);
 
     // We emitted an error for the unavailable/deleted function call but keep
     // the call in the AST.
     FunctionDecl *FDecl = (*Best)->Function;
-    Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
+    Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl,
+                                                (*Best)->Deduced);
     return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc,
                                          ExecConfig, /*IsExecConfig=*/false,
                                          (*Best)->IsADLCandidate);
   }
   }
 
   // Overload resolution failed, try to recover.
   SmallVector<Expr *, 8> SubExprs = {Fn};
case OR_Deleted:
                                   << DeclName << MemExprE->getSourceRange()),
           *this, OCD_AllCandidates, Args);
       break;
     }
     // Overload resolution fails, try to recover.
     if (!Succeeded)
       return BuildRecoveryExpr(chooseRecoveryType(CandidateSet, &Best));
 
-    MemExprE = FixOverloadedFunctionReference(MemExprE, FoundDecl, Method);
+    MemExprE = FixOverloadedFunctionReference(MemExprE, FoundDecl, Method,
+                                              Best->Deduced);
 
     // If overload resolution picked a static member, build a
     // non-member call based on that function.
     if (Method->isStatic()) {
       return BuildResolvedCallExpr(MemExprE, Method, LParenLoc, Args, RParenLoc,
                                    ExecConfig, IsExecConfig);
     }
 

 }
 
 
 /// FixOverloadedFunctionReference - E is an expression that refers to
 /// a C++ overloaded function (possibly with some parentheses and
 /// perhaps a '&' around it). We have resolved the overloaded function
 /// to the function declaration Fn, so patch up the expression E to
 /// refer (possibly indirectly) to Fn. Returns the new expr.
-Expr *Sema::FixOverloadedFunctionReference(Expr *E, DeclAccessPair Found,
-                                           FunctionDecl *Fn) {
+Expr *
+Sema::FixOverloadedFunctionReference(Expr *E, DeclAccessPair Found,
+                                     FunctionDecl *Fn,
+                                     const TemplateArgumentList *Deduced) {
   if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
-    Expr *SubExpr = FixOverloadedFunctionReference(PE->getSubExpr(),
-                                                   Found, Fn);
+    Expr *SubExpr =
+        FixOverloadedFunctionReference(PE->getSubExpr(), Found, Fn, Deduced);
     if (SubExpr == PE->getSubExpr())
       return PE;
 
     return new (Context) ParenExpr(PE->getLParen(), PE->getRParen(), SubExpr);
   }
 
   if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
-    Expr *SubExpr = FixOverloadedFunctionReference(ICE->getSubExpr(),
-                                                   Found, Fn);
+    Expr *SubExpr =
+        FixOverloadedFunctionReference(ICE->getSubExpr(), Found, Fn, Deduced);
     assert(Context.hasSameType(ICE->getSubExpr()->getType(),
                                SubExpr->getType()) &&
            "Implicit cast type cannot be determined from overload");
     assert(ICE->path_empty() && "fixing up hierarchy conversion?");
     if (SubExpr == ICE->getSubExpr())
       return ICE;
 
     return ImplicitCastExpr::Create(Context, ICE->getType(), ICE->getCastKind(),
                                     SubExpr, nullptr, ICE->getValueKind(),
                                     CurFPFeatureOverrides());
   }
 
   if (auto *GSE = dyn_cast<GenericSelectionExpr>(E)) {
     if (!GSE->isResultDependent()) {
-      Expr *SubExpr =
-          FixOverloadedFunctionReference(GSE->getResultExpr(), Found, Fn);
+      Expr *SubExpr = FixOverloadedFunctionReference(GSE->getResultExpr(),
+                                                     Found, Fn, Deduced);
       if (SubExpr == GSE->getResultExpr())
         return GSE;
 
       // Replace the resulting type information before rebuilding the generic
       // selection expression.
       ArrayRef<Expr *> A = GSE->getAssocExprs();
       SmallVector<Expr *, 4> AssocExprs(A.begin(), A.end());
       unsigned ResultIdx = GSE->getResultIndex();
       AssocExprs[ResultIdx] = SubExpr;
 
       return GenericSelectionExpr::Create(
           Context, GSE->getGenericLoc(), GSE->getControllingExpr(),
           GSE->getAssocTypeSourceInfos(), AssocExprs, GSE->getDefaultLoc(),
           GSE->getRParenLoc(), GSE->containsUnexpandedParameterPack(),
           ResultIdx);
     }
     // Rather than fall through to the unreachable, return the original generic
     // selection expression.
     return GSE;
   }
 
+  QualType Type = Fn->getType();
+  TemplateArgumentListInfo Args;
+  if (Deduced) {
+    Sema::SFINAETrap Trap(*this);
+    for (const TemplateArgument &I : Deduced->asArray())
+      Args.addArgument(
+          getTrivialTemplateArgumentLoc(I, QualType(), SourceLocation()));
+  }
+  Type = resugar(CXXScopeSpec(), Fn, &Args, Type, /*Escapes=*/true,
+                 /*AsWritten=*/false);
+
   if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(E)) {
     assert(UnOp->getOpcode() == UO_AddrOf &&
            "Can only take the address of an overloaded function");
     if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
       if (Method->isStatic()) {
         // Do nothing: static member functions aren't any different
         // from non-member functions.
       } else {
         // Fix the subexpression, which really has to be an
         // UnresolvedLookupExpr holding an overloaded member function
         // or template.
         Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(),
-                                                       Found, Fn);
+                                                       Found, Fn, Deduced);
         if (SubExpr == UnOp->getSubExpr())
           return UnOp;
 
         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.
         QualType ClassType
           = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
-        QualType MemPtrType
-          = Context.getMemberPointerType(Fn->getType(), ClassType.getTypePtr());
+        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());
       }
     }
-    Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(),
-                                                   Found, Fn);
+    Expr *SubExpr =
+        FixOverloadedFunctionReference(UnOp->getSubExpr(), Found, Fn, Deduced);
     if (SubExpr == UnOp->getSubExpr())
       return UnOp;
 
     // FIXME: This can't currently fail, but in principle it could.
     return CreateBuiltinUnaryOp(UnOp->getOperatorLoc(), UO_AddrOf, SubExpr)
         .get();
   }
 
   if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
     // FIXME: avoid copy.
     TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
     if (ULE->hasExplicitTemplateArgs()) {
       ULE->copyTemplateArgumentsInto(TemplateArgsBuffer);
       TemplateArgs = &TemplateArgsBuffer;
     }
 
-    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)) {
         Type = Context.BuiltinFnTy;
         ValueKind = VK_PRValue;
       }
     }
 
     DeclRefExpr *DRE = BuildDeclRefExpr(
         Fn, Type, ValueKind, ULE->getNameInfo(), ULE->getQualifierLoc(),
if (UnresolvedMemberExpr *MemExpr = dyn_cast<UnresolvedMemberExpr>(E)) {
     }
 
     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()) {
-        DeclRefExpr *DRE = BuildDeclRefExpr(
-            Fn, Fn->getType(), VK_LValue, MemExpr->getNameInfo(),
+        DeclRefExpr *DRE =
+            BuildDeclRefExpr(Fn, Type, VK_LValue, MemExpr->getNameInfo(),
                              MemExpr->getQualifierLoc(), Found.getDecl(),
                              MemExpr->getTemplateKeywordLoc(), TemplateArgs);
         DRE->setHadMultipleCandidates(MemExpr->getNumDecls() > 1);
         return DRE;
       } else {
         SourceLocation Loc = MemExpr->getMemberLoc();
         if (MemExpr->getQualifier())
           Loc = MemExpr->getQualifierLoc().getBeginLoc();
         Base =
             BuildCXXThisExpr(Loc, MemExpr->getBaseType(), /*IsImplicit=*/true);
       }
     } else
       Base = MemExpr->getBase();
 
     ExprValueKind valueKind;
-    QualType type;
     if (cast<CXXMethodDecl>(Fn)->isStatic()) {
       valueKind = VK_LValue;
-      type = 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);
   }
 
   llvm_unreachable("Invalid reference to overloaded function");
 }
 
-ExprResult Sema::FixOverloadedFunctionReference(ExprResult E,
-                                                DeclAccessPair Found,
-                                                FunctionDecl *Fn) {
-  return FixOverloadedFunctionReference(E.get(), Found, Fn);
+ExprResult
+Sema::FixOverloadedFunctionReference(ExprResult E, DeclAccessPair Found,
+                                     FunctionDecl *Fn,
+                                     const TemplateArgumentList *Deduced) {
+  return FixOverloadedFunctionReference(E.get(), Found, Fn, Deduced);
 }
 
 bool clang::shouldEnforceArgLimit(bool PartialOverloading,
                                   FunctionDecl *Function) {
   if (!PartialOverloading || !Function)
     return true;
   if (Function->isVariadic())
     return false;

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;
 }
 
+static TemplateArgumentLoc
+getNullTemplateArgumentLoc(ASTContext &Context, const TemplateArgument &A) {
+  switch (A.getKind()) {
+  case TemplateArgument::Type:
+    return TemplateArgumentLoc(
+        A, TemplateArgumentLocInfo((TypeSourceInfo *)nullptr));
+  case TemplateArgument::Template:
+  case TemplateArgument::TemplateExpansion: {
+    const auto &T = A.getAsTemplateOrTemplatePattern();
+
+    NestedNameSpecifier *NNS = nullptr;
+    if (const QualifiedTemplateName *QTN = T.getAsQualifiedTemplateName())
+      NNS = QTN->getQualifier();
+    else if (const DependentTemplateName *DTN = T.getAsDependentTemplateName())
+      NNS = DTN->getQualifier();
+    NestedNameSpecifierLocBuilder Builder;
+    Builder.MakeTrivial(Context, NNS, SourceRange());
+
+    return TemplateArgumentLoc(
+        A,
+        TemplateArgumentLocInfo(Context, Builder.getWithLocInContext(Context),
+                                SourceLocation(), SourceLocation()));
+  }
+  default:
+    return TemplateArgumentLoc(A, TemplateArgumentLocInfo());
+  }
+  llvm_unreachable("");
+}
+
+TemplateDecl *getTemplateDecl(NamedDecl *D) {
+  if (!D)
+    return nullptr;
+  switch (auto K = D->getKind()) {
+  case Decl::Kind::Var:
+  case Decl::Kind::ParmVar:
+  case Decl::Kind::Field:
+  case Decl::Kind::IndirectField:
+  case Decl::Kind::EnumConstant:
+  case Decl::Kind::Binding:
+  case Decl::Kind::ImplicitParam:
+  case Decl::Kind::MSGuid:
+  case Decl::Kind::MSProperty:
+  case Decl::Kind::NonTypeTemplateParm:
+  case Decl::Kind::TemplateParamObject:
+    return nullptr;
+  case Decl::Kind::FunctionTemplate:
+  case Decl::Kind::ClassTemplate:
+  case Decl::Kind::TypeAliasTemplate:
+  case Decl::Kind::BuiltinTemplate:
+    return cast<TemplateDecl>(D);
+  case Decl::Kind::VarTemplateSpecialization:
+    return cast<VarTemplateSpecializationDecl>(D)->getSpecializedTemplate();
+  case Decl::Kind::CXXDeductionGuide:
+    return cast<CXXDeductionGuideDecl>(D)->getDeducedTemplate();
+  case Decl::Kind::CXXConversion:
+  case Decl::Kind::CXXConstructor:
+  case Decl::Kind::CXXDestructor:
+  case Decl::Kind::CXXMethod:
+  case Decl::Kind::Function: {
+    const auto *FD = cast<FunctionDecl>(D);
+    switch (auto K = FD->getTemplatedKind()) {
+    case FunctionDecl::TK_NonTemplate:
+      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;
+    default:
+      break;
+    }
+    llvm_unreachable("Unhandled function template kind");
+  }
+  case Decl::Kind::CXXRecord:
+    return cast<CXXRecordDecl>(D)->getDescribedClassTemplate();
+  case Decl::Kind::TemplateTemplateParm:
+    return cast<TemplateTemplateParmDecl>(D);
+  default:
+    // Maybe fall back to Decl::getDescribedTemplate.
+    D->dumpColor();
+    llvm_unreachable("Unhandled decl kind");
+  }
+}
+
+namespace {
+class Resugarer : public TreeTransform<Resugarer> {
+  using inherited = TreeTransform<Resugarer>;
+
+  struct Inner {
+    llvm::SmallPtrSet<const NamedDecl *, 4> Parms;
+    ArrayRef<TemplateArgument> Args;
+  };
+  Inner CurInner;
+
+  using ParmToArgs =
+      llvm::DenseMap<const NamedDecl *, ArrayRef<TemplateArgument>>;
+  ParmToArgs CurParmToArgs;
+
+  SmallVector<SmallVector<TemplateArgument, 0>, 4> ArgsBuf;
+
+  const TemplateArgument *getArgument(const NamedDecl *ND, unsigned Index,
+                                      Optional<unsigned> PackIndex) const {
+    ArrayRef<TemplateArgument> Args;
+    if (!CurInner.Args.empty() && CurInner.Parms.contains(ND))
+      Args = CurInner.Args;
+    else {
+      auto It = CurParmToArgs.find(ND);
+      if (It == CurParmToArgs.end())
+        return nullptr;
+      Args = It->second;
+    }
+    const TemplateArgument &Arg = Args[Index];
+    return PackIndex ? &Arg.getPackAsArray()[*PackIndex] : &Arg;
+  }
+
+  struct BaseSemanticContextRAII {
+    BaseSemanticContextRAII(Resugarer &R)
+        : R(&R), OldInner(std::move(R.CurInner)) {}
+    ~BaseSemanticContextRAII() { R->CurInner = std::move(OldInner); }
+
+  protected:
+    Resugarer *R;
+
+  private:
+    Inner OldInner;
+  };
+
+public:
+  struct NonTemplateSemanticContextRAII {
+    NonTemplateSemanticContextRAII(Resugarer &R)
+        : R(&R), OldInner(std::exchange(R.CurInner, {})) {}
+    ~NonTemplateSemanticContextRAII() { R->CurInner = std::move(OldInner); }
+
+  protected:
+    Resugarer *R;
+
+  private:
+    Inner OldInner;
+  };
+
+  struct SemanticContextRAII : private NonTemplateSemanticContextRAII {
+    SemanticContextRAII(Resugarer &R, NamedDecl *ND,
+                        const TemplateArgumentListInfo *Args,
+                        bool AsWritten = true)
+        : NonTemplateSemanticContextRAII(R), OldArgsBufSize(R.ArgsBuf.size()) {
+      if (!Args || Args->size() == 0)
+        return;
+      TemplateDecl *TD = getTemplateDecl(ND);
+      if (!TD)
+        return;
+      for (const NamedDecl *TP : TD->getTemplateParameters()->asArray())
+        R.CurInner.Parms.insert(TP);
+
+      SmallVector<TemplateArgument, 0> ConvertedArgs;
+      if (!AsWritten) {
+        ConvertedArgs.reserve(Args->arguments().size());
+        for (const TemplateArgumentLoc &I : Args->arguments())
+          ConvertedArgs.push_back(I.getArgument());
+        R.CurInner.Args = R.ArgsBuf.emplace_back(std::move(ConvertedArgs));
+        return;
+      }
+
+      Sema::SFINAETrap Trap(R.SemaRef);
+      if (R.SemaRef.CheckTemplateArgumentList(
+              TD, SourceLocation(),
+              *const_cast<TemplateArgumentListInfo *>(Args), false,
+              ConvertedArgs,
+              /*UpdateArgsWithConversions=*/false,
+              /*ConstrantsNotSatisfied=*/nullptr,
+              /*DontCanonicalize=*/true))
+        llvm_unreachable("Unexpected conversion failure");
+      switch (ND->getKind()) {
+      case Decl::Kind::TypeAliasTemplate:
+      case Decl::Kind::BuiltinTemplate:
+      case Decl::Kind::CXXMethod:
+      case Decl::Kind::Function:
+        break;
+      case Decl::Kind::VarTemplateSpecialization: {
+        auto *VD = cast<VarTemplateSpecializationDecl>(ND);
+        auto *VTPSD = VD->getSpecializedTemplateOrPartial()
+                          .dyn_cast<VarTemplatePartialSpecializationDecl *>();
+        if (!VTPSD)
+          break;
+        TemplateParameterList *TPL = VTPSD->getTemplateParameters();
+        TemplateDeductionInfo Info(SourceLocation{}, TPL->getDepth());
+        // FIXME: We can't deal very well with non-canonical template
+        //        arguments so this will fail sometimes.
+        Sema::TemplateDeductionResult Res = R.SemaRef.DeduceTemplateArguments(
+            VTPSD,
+            TemplateArgumentList(TemplateArgumentList::OnStackType{},
+                                 ConvertedArgs),
+            Info,
+            /*DontCaninicalize=*/true);
+        if (Res != Sema::TDK_Success)
+          break;
+        R.CurInner.Args = Info.take()->asArray();
+        return;
+      }
+      default:
+        ND->dump();
+        llvm_unreachable("Unhandled Template Kind");
+      }
+      R.CurInner.Args = R.ArgsBuf.emplace_back(std::move(ConvertedArgs));
+    }
+
+    ~SemanticContextRAII() { R->ArgsBuf.resize(OldArgsBufSize); }
+
+    size_t OldArgsBufSize;
+  };
+
+  struct NamingContextBase {
+    NamingContextBase(Resugarer &R)
+        : R(&R), OldParmToArgs(std::move(R.CurParmToArgs)),
+          OldArgsBufSize(R.ArgsBuf.size()) {}
+    ~NamingContextBase() {
+      R->CurParmToArgs = std::move(OldParmToArgs);
+      R->ArgsBuf.resize(OldArgsBufSize);
+    }
+
+  protected:
+    void insertTPLToMap(bool Reverse, const TemplateParameterList *TPL,
+                        ArrayRef<TemplateArgument> Args) {
+      assert(!Args.empty());
+      if (Reverse) {
+        for (const NamedDecl *TP : TPL->asArray())
+          if (!R->CurParmToArgs.try_emplace(TP, Args).second)
+            break;
+      } else {
+        for (const NamedDecl *TP : TPL->asArray())
+          R->CurParmToArgs[TP] = Args;
+      }
+    }
+
+    void deduceClassTemplatePartialSpecialization(
+        ClassTemplatePartialSpecializationDecl *D, bool Reverse,
+        ArrayRef<TemplateArgument> Args) {
+      TemplateParameterList *TPL = D->getTemplateParameters();
+      TemplateDeductionInfo Info(SourceLocation{}, TPL->getDepth());
+      // FIXME: We can't deal very well with non-canonical template
+      //        arguments so this will fail sometimes.
+      Sema::TemplateDeductionResult Res = R->SemaRef.DeduceTemplateArguments(
+          D, TemplateArgumentList(TemplateArgumentList::OnStackType{}, Args),
+          Info,
+          /*DontCaninicalize=*/true);
+      if (Res != Sema::TDK_Success)
+        return;
+      insertTPLToMap(Reverse, TPL, Info.take()->asArray());
+    }
+
+    void addTypeToMap(bool Reverse, const Type *T) {
+      struct {
+        NamedDecl *ND;
+        const TemplateSpecializationType *TS;
+      } Entity;
+      {
+        QualType TCanon = T->getCanonicalTypeInternal();
+        switch (TCanon->getTypeClass()) {
+        case Type::Record: {
+          const auto *TS = T->getAs<TemplateSpecializationType>();
+          while (TS && TS->isTypeAlias())
+            TS = TS->getAliasedType()->getAs<TemplateSpecializationType>();
+          Entity = {T->getAsRecordDecl(), TS};
+          break;
+        }
+        case Type::InjectedClassName: {
+          const auto *ICN = cast<InjectedClassNameType>(TCanon);
+          Entity = {ICN->getDecl(), ICN->getInjectedTST()};
+          break;
+        }
+        case Type::TemplateSpecialization:
+        case Type::DependentTemplateSpecialization:
+        case Type::TemplateTypeParm:
+        case Type::DependentName:
+        case Type::Enum:
+        case Type::Builtin:
+          return;
+        default:
+          TCanon.dump();
+          llvm_unreachable("");
+        }
+      }
+      switch (auto NDK = Entity.ND->getKind()) {
+      default:
+        Entity.ND->dumpColor();
+        llvm_unreachable("");
+      case Decl::CXXRecord:
+        return;
+      case Decl::ClassTemplateSpecialization:
+      case Decl::ClassTemplatePartialSpecialization:
+        if (!Entity.TS)
+          return;
+        assert(!Entity.TS->isTypeAlias());
+        ArrayRef<TemplateArgument> Args = Entity.TS->template_arguments();
+
+        if (NDK == Decl::ClassTemplatePartialSpecialization)
+          return deduceClassTemplatePartialSpecialization(
+              cast<ClassTemplatePartialSpecializationDecl>(Entity.ND), Reverse,
+              Args);
+
+        auto *CTSD = cast<ClassTemplateSpecializationDecl>(Entity.ND);
+        TemplateArgumentListInfo ArgsInfo;
+        for (auto &&I : Args)
+          ArgsInfo.addArgument(R->SemaRef.getTrivialTemplateArgumentLoc(
+              I, /*NTTPType=*/QualType(), SourceLocation()));
+
+        ClassTemplateDecl *TD = CTSD->getSpecializedTemplate();
+        SmallVector<TemplateArgument, 4> ConvertedArgs;
+        if (R->SemaRef.CheckTemplateArgumentList(
+                TD, SourceLocation(), ArgsInfo, false, ConvertedArgs,
+                /*UpdateArgsWithConversions=*/false,
+                /*ConstrantsNotSatisfied=*/nullptr,
+                /*DontCanonicalize=*/true))
+          llvm_unreachable("Unexpected conversion failure");
+        if (auto *CTPSD =
+                CTSD->getSpecializedTemplateOrPartial()
+                    .dyn_cast<ClassTemplatePartialSpecializationDecl *>())
+          return deduceClassTemplatePartialSpecialization(CTPSD, Reverse,
+                                                          ConvertedArgs);
+        return insertTPLToMap(
+            Reverse, TD->getTemplateParameters(),
+            R->ArgsBuf.emplace_back(std::move(ConvertedArgs)));
+      }
+      llvm_unreachable("Unhandled IDC Kind");
+    }
+
+    Resugarer *R;
+    ParmToArgs OldParmToArgs;
+
+  private:
+    size_t OldArgsBufSize;
+  };
+
+  struct NamingContextRAII : NamingContextBase {
+    NamingContextRAII(Resugarer &R, const NestedNameSpecifier *NNS)
+        : NamingContextBase(R) {
+      for (/**/; NNS; NNS = NNS->getPrefix()) {
+        switch (auto NNSK = 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 : OldParmToArgs) {
+        auto &P = R.CurParmToArgs[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.CurParmToArgs.copyFrom(OldParmToArgs);
+
+      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 TransformElaboratedType(TypeLocBuilder &TLB, ElaboratedTypeLoc TL) {
+    NestedNameSpecifierLoc QualifierLoc = TL.getQualifierLoc();
+    NamingContextTransformRAII NamingScope(*this, QualifierLoc);
+    QualType NamedT = TransformType(TLB, TL.getNamedTypeLoc());
+
+    const ElaboratedType *T = TL.getTypePtr();
+    QualType Result = TL.getType();
+    if (QualifierLoc != TL.getQualifierLoc() || NamedT != T->getNamedType())
+      Result = SemaRef.Context.getElaboratedType(
+          T->getKeyword(), QualifierLoc.getNestedNameSpecifier(), NamedT);
+
+    auto NewTL = TLB.push<ElaboratedTypeLoc>(Result);
+    NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
+    NewTL.setQualifierLoc(QualifierLoc);
+    return Result;
+  }
+
+  Decl *TransformDecl(SourceLocation Loc, Decl *D) const { return D; }
+
+  QualType TransformSubstTemplateTypeParmType(TypeLocBuilder &TLB,
+                                              SubstTemplateTypeParmTypeLoc TL) {
+    QualType QT = TL.getType();
+    const SubstTemplateTypeParmType *T = TL.getTypePtr();
+    const TemplateTypeParmType *Replaced = T->getReplacedParameter();
+
+    Optional<unsigned> PackIndex = T->getPackIndex();
+    if (const TemplateArgument *Arg =
+            getArgument(Replaced->getDecl(), Replaced->getIndex(), PackIndex)) {
+      QualType Replacement = Arg->getAsType().getNonPackExpansionType();
+      if (!SemaRef.Context.hasSameType(Replacement, T->getReplacementType())/* &&
+        Replacement->getTypeClass() != Type::Decltype &&
+        T->getReplacementType()->getTypeClass() != Type::Decltype*/) {
+        Replacement.dump();
+        T->getReplacementType().dump();
+        assert(false);
+      }
+      if (Replacement != T->getReplacementType())
+        QT = SemaRef.Context.getSubstTemplateTypeParmType(Replaced, Replacement,
+                                                          PackIndex);
+    }
+    auto NewTL = TLB.push<SubstTemplateTypeParmTypeLoc>(QT);
+    NewTL.setNameLoc(TL.getNameLoc());
+    return QT;
+  }
+
+  using inherited::TransformTemplateSpecializationType;
+
+  template <typename ArgIterator>
+  QualType TransformTemplateSpecializationType(
+      TemplateName N, bool IsTypeAlias, ArgIterator First, ArgIterator Last,
+      TemplateArgumentListInfo &NewArgs, QualType Underlying) {
+    if (const SubstTemplateTemplateParmStorage *STTP =
+            N.getAsSubstTemplateTemplateParm()) {
+      // FIXME: Resugar default arguments on template template parameters.
+      //        The AST currently cannot represent this.
+      if (TransformTemplateArguments(First, Last, NewArgs))
+        llvm_unreachable("");
+    } else {
+      if (TransformTemplateArguments(First, Last, NewArgs))
+        llvm_unreachable("");
+    }
+    if (IsTypeAlias) {
+      SemanticContextRAII SemanticScope(*this, N.getAsTemplateDecl(), &NewArgs);
+      Underlying = TransformType(Underlying);
+    }
+    return SemaRef.Context.getTemplateSpecializationType(N, NewArgs,
+                                                         Underlying);
+  }
+
+  QualType TransformTemplateSpecializationType(TypeLocBuilder &TLB,
+                                               TemplateSpecializationTypeLoc TL,
+                                               TemplateName N) {
+    const TemplateSpecializationType *T = TL.getTypePtr();
+
+    TemplateArgumentListInfo NewArgs;
+    NewArgs.setLAngleLoc(TL.getLAngleLoc());
+    NewArgs.setRAngleLoc(TL.getRAngleLoc());
+    using Iter =
+        TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc>;
+    QualType Result = TransformTemplateSpecializationType(
+        N, T->isTypeAlias(), Iter(TL, 0), Iter(TL, TL.getNumArgs()), NewArgs,
+        T->desugar());
+    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 = NewArgs.size(); i != e; ++i)
+      NewTL.setArgLocInfo(i, NewArgs[i].getLocInfo());
+    return Result;
+  }
+
+  template <typename ArgIterator>
+  QualType TransformDependentTemplateSpecializationType(
+      ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
+      const IdentifierInfo *ID, ArgIterator First, ArgIterator Last,
+      TemplateArgumentListInfo &NewArgs) {
+    if (TransformTemplateArguments(First, Last, NewArgs))
+      llvm_unreachable("");
+    // FIXME: don't rebuild if nothing changed.
+    return SemaRef.Context.getDependentTemplateSpecializationType(Keyword, NNS,
+                                                                  ID, NewArgs);
+  }
+
+  template <typename ArgIterator>
+  QualType TransformDependentTemplateSpecializationType(
+      ElaboratedTypeKeyword Keyword, NestedNameSpecifierLoc &NNS,
+      const IdentifierInfo *ID, ArgIterator First, ArgIterator Last,
+      TemplateArgumentListInfo &NewArgs) {
+    NamingContextTransformRAII NamingScope(*this, NNS);
+    return TransformDependentTemplateSpecializationType(
+        Keyword, NNS.getNestedNameSpecifier(), ID, First, Last, NewArgs);
+  }
+
+  QualType TransformDependentTemplateSpecializationType(
+      TypeLocBuilder &TLB, DependentTemplateSpecializationTypeLoc TL) {
+    const DependentTemplateSpecializationType *T = TL.getTypePtr();
+    TemplateArgumentListInfo NewArgs;
+    NewArgs.setLAngleLoc(TL.getLAngleLoc());
+    NewArgs.setRAngleLoc(TL.getRAngleLoc());
+
+    using Iter = TemplateArgumentLocContainerIterator<
+        DependentTemplateSpecializationTypeLoc>;
+    NestedNameSpecifierLoc NNS = TL.getQualifierLoc();
+    QualType Result = TransformDependentTemplateSpecializationType(
+        T->getKeyword(), NNS, T->getIdentifier(), Iter(TL, 0),
+        Iter(TL, TL.getNumArgs()), NewArgs);
+
+    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 = NewArgs.size(); i != e; ++i)
+      NewTL.setArgLocInfo(i, NewArgs[i].getLocInfo());
+    return Result;
+  }
+
+  TypeSourceInfo *TransformTSIInObjectScope(TypeLoc TL, QualType, NamedDecl *,
+                                            CXXScopeSpec &) {
+    llvm_unreachable("unused");
+  }
+
+  QualType TransformDependentTemplateSpecializationType(
+      TypeLocBuilder &, DependentTemplateSpecializationTypeLoc, TemplateName,
+      CXXScopeSpec &) {
+    llvm_unreachable("unused");
+  }
+
+  TemplateName TransformTemplateName(CXXScopeSpec &SS, TemplateName Name,
+                                     SourceLocation NameLoc,
+                                     QualType ObjectType = QualType(),
+                                     NamedDecl *FirstQualifierInScope = nullptr,
+                                     bool AllowInjectedClassName = false) {
+    if (Name.getKind() == TemplateName::NameKind::SubstTemplateTemplateParm)
+      return Name; // FIXME: resugar these
+    return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,
+                                            FirstQualifierInScope,
+                                            AllowInjectedClassName);
+  }
+
+  QualType TransformDependentNameType(TypeLocBuilder &TLB,
+                                      DependentNameTypeLoc TL,
+                                      bool DeducedTSTContext = false) {
+    const DependentNameType *T = TL.getTypePtr();
+
+    NestedNameSpecifierLoc QualifierLoc = TL.getQualifierLoc();
+    NamingContextTransformRAII NamingContext(*this, QualifierLoc);
+    assert(QualifierLoc);
+    assert(QualifierLoc.getNestedNameSpecifier()->isDependent());
+    QualType Result = SemaRef.Context.getDependentNameType(
+        T->getKeyword(), QualifierLoc.getNestedNameSpecifier(),
+        T->getIdentifier());
+    auto NewTL = TLB.push<DependentNameTypeLoc>(Result);
+    NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
+    NewTL.setQualifierLoc(QualifierLoc);
+    NewTL.setNameLoc(TL.getNameLoc());
+    return Result;
+  }
+
+  QualType TransformTypedefType(TypeLocBuilder &TLB, TypedefTypeLoc TL) {
+    const TypedefType *T = TL.getTypePtr();
+    const TypedefNameDecl *D = T->getDecl();
+    QualType OldUnderlying = T->desugar();
+    NonTemplateSemanticContextRAII SemanticScope(*this);
+    QualType NewUnderlying = TransformType(OldUnderlying);
+    QualType Result = TL.getType();
+    if (NewUnderlying != OldUnderlying)
+      Result = SemaRef.Context.getTypedefType(D, NewUnderlying);
+    auto NewTL = TLB.push<TypedefTypeLoc>(Result);
+    NewTL.setNameLoc(TL.getNameLoc());
+    return Result;
+  }
+
+  QualType TransformUsingType(TypeLocBuilder &TLB, UsingTypeLoc TL) {
+    const UsingType *T = TL.getTypePtr();
+    const UsingShadowDecl *D = T->getFoundDecl();
+    QualType OldUnderlying = T->desugar();
+    NonTemplateSemanticContextRAII SemanticScope(*this);
+    QualType NewUnderlying = TransformType(OldUnderlying);
+    QualType Result = TL.getType();
+    if (NewUnderlying != OldUnderlying)
+      Result = SemaRef.Context.getUsingType(D, NewUnderlying);
+    TLB.pushTypeSpec(Result).setNameLoc(TL.getNameLoc());
+    return Result;
+  }
+
+  ExprResult TransformExpr(Expr *E) { return E; }
+
+  bool TransformTemplateArgument(const TemplateArgumentLoc &Input,
+                                 TemplateArgumentLoc &Output, bool) {
+    const TemplateArgument &Arg = Input.getArgument();
+    switch (Arg.getKind()) {
+    case TemplateArgument::Null:
+      llvm_unreachable("Unexpected Null TemplateArgument");
+    case TemplateArgument::Pack: {
+      TemplateArgumentListInfo Ins;
+      for (const TemplateArgument &I : Arg.getPackAsArray())
+        Ins.addArgument(getNullTemplateArgumentLoc(SemaRef.Context, I));
+      TemplateArgumentListInfo Outs;
+      TransformTemplateArguments(Ins.arguments().begin(), Ins.arguments().end(),
+                                 Outs);
+      SmallVector<TemplateArgument, 4> ROuts(Outs.size());
+      for (unsigned I = 0; I < Outs.size(); ++I)
+        ROuts[I] = Outs[I].getArgument();
+      Output = TemplateArgumentLoc(
+          TemplateArgument::CreatePackCopy(SemaRef.Context, ROuts),
+          Input.getLocInfo());
+      return false;
+    }
+    case TemplateArgument::Integral:
+    case TemplateArgument::NullPtr:
+    case TemplateArgument::Declaration: {
+      // Transform a resolved template argument straight to a resolved template
+      // argument. We get here when substituting into an already-substituted
+      // template type argument during concept satisfaction checking.
+      QualType T = Arg.getNonTypeTemplateArgumentType();
+      QualType NewT = TransformType(T);
+      assert(!NewT.isNull());
+      if (NewT == T)
+        Output = Input;
+      else if (Arg.getKind() == TemplateArgument::Integral)
+        Output = TemplateArgumentLoc(
+            TemplateArgument(SemaRef.Context, Arg.getAsIntegral(), NewT),
+            Input.getLocInfo());
+      else if (Arg.getKind() == TemplateArgument::NullPtr)
+        Output = TemplateArgumentLoc(TemplateArgument(NewT, /*IsNullPtr=*/true),
+                                     Input.getLocInfo());
+      else
+        Output = TemplateArgumentLoc(TemplateArgument(Arg.getAsDecl(), NewT),
+                                     Input.getLocInfo());
+      return false;
+    }
+
+    case TemplateArgument::Type: {
+      if (Arg.isPackExpansion()) {
+        QualType T = TransformType(Arg.getAsType());
+        assert(!T.isNull());
+        Output = TemplateArgumentLoc(TemplateArgument(T), Input.getLocInfo());
+        return false;
+      }
+      TypeSourceInfo *DI = Input.getTypeSourceInfo();
+      if (!DI)
+        DI = InventTypeSourceInfo(Arg.getAsType());
+
+      DI = TransformType(DI);
+      if (!DI)
+        return true;
+
+      Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);
+      return false;
+    }
+
+    case TemplateArgument::Template: {
+      NestedNameSpecifierLoc QualifierLoc = Input.getTemplateQualifierLoc();
+      NamingContextTransformRAII NamingContext(*this, QualifierLoc);
+
+      CXXScopeSpec SS;
+      SS.Adopt(QualifierLoc);
+      TemplateName Template = TransformTemplateName(SS, Arg.getAsTemplate(),
+                                                    Input.getTemplateNameLoc());
+      assert(!Template.isNull());
+
+      Output = TemplateArgumentLoc(SemaRef.Context, TemplateArgument(Template),
+                                   QualifierLoc, Input.getTemplateNameLoc());
+      return false;
+    }
+
+    case TemplateArgument::TemplateExpansion: {
+      Output = TemplateArgumentLoc(
+          TemplateArgument(Arg.getAsTemplateOrTemplatePattern(),
+                           Arg.getNumTemplateExpansions()),
+          Input.getLocInfo());
+      return false;
+    }
+    case TemplateArgument::Expression: {
+      // FIXME: convert the type of these.
+      Output = Input;
+      return false;
+    }
+    }
+    llvm_unreachable("Unexpected TemplateArgument kind");
+  }
+
+  template <typename InputIterator>
+  bool TransformTemplateArguments(InputIterator First, InputIterator Last,
+                                  TemplateArgumentListInfo &Outputs,
+                                  bool Uneval = true) {
+    for (; First != Last; ++First) {
+      TemplateArgumentLoc Out;
+      if (TransformTemplateArgument(*First, Out, Uneval))
+        llvm_unreachable("");
+      Outputs.addArgument(Out);
+    }
+    return false;
+  }
+
+  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();
+
+    TemplateArgumentListInfo NewArgs;
+    if (T->isConstrained()) {
+      NewArgs.setLAngleLoc(TL.getLAngleLoc());
+      NewArgs.setRAngleLoc(TL.getRAngleLoc());
+      using Iter = TemplateArgumentLocContainerIterator<AutoTypeLoc>;
+      if (TransformTemplateArguments(Iter(TL, 0), Iter(TL, TL.getNumArgs()),
+                                     NewArgs))
+        llvm_unreachable("");
+    }
+
+    QualType Deduced = !T->getDeducedType().isNull()
+                           ? TransformType(T->getDeducedType())
+                           : QualType();
+
+    QualType Result = TL.getType();
+    if (Deduced != T->getDeducedType()) {
+      NNS = TL.getNestedNameSpecifierLoc();
+      NamingContextTransformRAII NamingContext(*this, NNS);
+      // FIXME: Maybe don't rebuild if all template arguments are the same.
+      llvm::SmallVector<TemplateArgument, 4> TypeConstraintArgs(NewArgs.size());
+      for (const auto &ArgLoc : NewArgs.arguments())
+        TypeConstraintArgs.push_back(ArgLoc.getArgument());
+      Result = SemaRef.Context.getAutoType(
+          Deduced, T->getKeyword(), T->isInstantiationDependentType(),
+          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, NewArgs[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);
+    }
+    auto NewTL = 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, NamedDecl *ND,
+                       const TemplateArgumentListInfo *Args, QualType T, bool,
+                       bool AsWritten) {
+  if (!getLangOpts().Resugar)
+    return T;
+  Resugarer R(*this);
+  Resugarer::NamingContextRAII NamingScope(R, SS.getScopeRep());
+  Resugarer::SemanticContextRAII SemanticScope(R, ND, Args, AsWritten);
+  return R.TransformType(T);
+}
+
+QualType Sema::resugarEscapes(QualType T) { return T; }
+
+bool Sema::resugarTemplateArguments(const CXXScopeSpec &SS,
+                                    TemplateArgumentListInfo &Args) {
+  if (!getLangOpts().Resugar)
+    return false;
+
+  Resugarer R(*this);
+  Resugarer::NamingContextRAII NamingScope(R, SS.getScopeRep());
+  Resugarer::NonTemplateSemanticContextRAII SemanticScope(R);
+  TemplateArgumentListInfo NewArgs;
+  if (R.TransformTemplateArguments(Args.arguments().begin(),
+                                   Args.arguments().end(), NewArgs))
+    llvm_unreachable("Unexpected failure");
+  for (unsigned I = 0; I < Args.size(); ++I)
+    if (!Args[I].getArgument().structurallyEquals(NewArgs[I].getArgument())) {
+      Args = std::move(NewArgs);
+      return true;
+    }
+  return false;
+}
+
+static QualType getResugaredTemplateSpecializationType(
+    Sema &S, NestedNameSpecifier *NNS, TemplateName Template,
+    TemplateArgumentListInfo &Args, QualType Underlying = QualType()) {
+  if (!S.getLangOpts().Resugar)
+    return S.Context.getTemplateSpecializationType(Template, Args, Underlying);
+  Resugarer R(S);
+  Resugarer::NamingContextRAII NamingScope(R, NNS);
+  const auto *TD = Template.getAsTemplateDecl();
+  bool IsTypeAlias = !Underlying.isNull() && TD && TD->isTypeAlias();
+  TemplateArgumentListInfo NewArgs;
+  QualType Result = R.TransformTemplateSpecializationType(
+      Template, IsTypeAlias, Args.arguments().begin(), Args.arguments().end(),
+      NewArgs, Underlying);
+  Args = std::move(NewArgs);
+  return Result;
+}
+
 /// \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,
NamedDecl *Sema::ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
   // Check the well-formedness of the default template argument, if provided.
   if (Default) {
     // Check for unexpanded parameter packs.
     if (DiagnoseUnexpandedParameterPack(Default, UPPC_DefaultArgument))
       return Param;
 
     TemplateArgument Converted;
     ExprResult DefaultRes =
-        CheckTemplateArgument(Param, Param->getType(), Default, Converted);
+        CheckTemplateArgument(Param, Param->getType(), Default, Converted,
+                              CTAK_Specified, /*DontCanonicalize=*/false);
     if (DefaultRes.isInvalid()) {
       Param->setInvalidDecl();
       return Param;
     }
     Default = DefaultRes.get();
 
     Param->setDefaultArgument(Default);
   }
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,
+checkBuiltinTemplateIdType(Sema &SemaRef, const CXXScopeSpec &SS,
+                           TemplateName Name, BuiltinTemplateDecl *BTD,
                            const SmallVectorImpl<TemplateArgument> &Converted,
                            SourceLocation TemplateLoc,
                            TemplateArgumentListInfo &TemplateArgs) {
   ASTContext &Context = SemaRef.getASTContext();
   switch (BTD->getBuiltinTemplateKind()) {
   case BTK__make_integer_seq: {
     // Specializations of __make_integer_seq<S, T, N> are treated like
     // S<T, 0, ..., N-1>.
if (NumArgs < 0) {
                    diag::err_integer_sequence_negative_length);
       return QualType();
     }
 
     QualType ArgTy = NumArgsArg.getIntegralType();
     TemplateArgumentListInfo SyntheticTemplateArgs;
     // The type argument gets reused as the first template argument in the
     // synthetic template argument list.
-    SyntheticTemplateArgs.addArgument(TemplateArgs[1]);
+    auto *TTPD =
+        cast<TemplateTypeParmDecl>(BTD->getTemplateParameters()->getParam(1));
+    const auto *TTP = cast<TemplateTypeParmType>(
+        SemaRef.Context.getTemplateTypeParmType(0, 1, false, TTPD));
+    QualType OrigType = TemplateArgs[1].getArgument().getAsType();
+    QualType SyntheticType =
+        SemaRef.Context.getSubstTemplateTypeParmType(TTP, OrigType, None);
+    SyntheticTemplateArgs.addArgument(
+        TemplateArgumentLoc(TemplateArgument(SyntheticType),
+                            SemaRef.Context.getTrivialTypeSourceInfo(
+                                SyntheticType, TemplateArgs[1].getLocation())));
     // Expand N into 0 ... N-1.
     for (llvm::APSInt I(NumArgs.getBitWidth(), NumArgs.isUnsigned());
          I < NumArgs; ++I) {
       TemplateArgument TA(Context, I, ArgTy);
       SyntheticTemplateArgs.addArgument(SemaRef.getTrivialTemplateArgumentLoc(
           TA, ArgTy, TemplateArgs[2].getLocation()));
     }
     // The first template argument will be reused as the template decl that
     // our synthetic template arguments will be applied to.
-    return SemaRef.CheckTemplateIdType(Converted[0].getAsTemplate(),
-                                       TemplateLoc, SyntheticTemplateArgs);
+    QualType Result = SemaRef.CheckTemplateIdType(
+        SS, Converted[0].getAsTemplate(), TemplateLoc, SyntheticTemplateArgs);
+    return SemaRef.Context.getTemplateSpecializationType(Name, TemplateArgs,
+                                                         Result);
   }
 
   case BTK__type_pack_element:
     // Specializations of
     //    __type_pack_element<Index, T_1, ..., T_N>
     // are treated like T_Index.
     assert(Converted.size() == 2 &&
       "__type_pack_element should be given an index and a parameter pack");
 
     // If the Index is out of bounds, the program is ill-formed.
     TemplateArgument IndexArg = Converted[0], Ts = Converted[1];
     llvm::APSInt Index = IndexArg.getAsIntegral();
     assert(Index >= 0 && "the index used with __type_pack_element should be of "
                          "type std::size_t, and hence be non-negative");
     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`.
+    // FIXME: test this
     auto Nth = std::next(Ts.pack_begin(), Index.getExtValue());
-    return Nth->getAsType();
+    return getResugaredTemplateSpecializationType(
+        SemaRef, SS.getScopeRep(), Name, TemplateArgs, Nth->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") ||
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())
+  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
     // dependent name is substituted.
-    return Context.getDependentTemplateSpecializationType(ETK_None,
-                                                          DTN->getQualifier(),
-                                                          DTN->getIdentifier(),
-                                                          TemplateArgs);
+    resugarTemplateArguments(SS, TemplateArgs);
+    return Context.getDependentTemplateSpecializationType(
+        ETK_None, DTN->getQualifier(), DTN->getIdentifier(), TemplateArgs);
+  }
 
   if (Name.getAsAssumedTemplateName() &&
       resolveAssumedTemplateNameAsType(/*Scope*/nullptr, Name, TemplateLoc))
     return QualType();
 
   TemplateDecl *Template = Name.getAsTemplateDecl();
   if (!Template || isa<FunctionTemplateDecl>(Template) ||
       isa<VarTemplateDecl>(Template) || isa<ConceptDecl>(Template)) {
     // We might have a substituted template template parameter pack. If so,
     // build a template specialization type for it.
     if (Name.getAsSubstTemplateTemplateParmPack())
-      return Context.getTemplateSpecializationType(Name, TemplateArgs);
+      return getResugaredTemplateSpecializationType(*this, SS.getScopeRep(),
+                                                    Name, TemplateArgs);
 
     Diag(TemplateLoc, diag::err_template_id_not_a_type)
       << Name;
     NoteAllFoundTemplates(Name);
     return QualType();
   }
 
   // Check that the template argument list is well-formed for this
if (TypeAliasTemplateDecl *AliasTemplate =
 
     // Diagnose uses of this specialization.
     (void)DiagnoseUseOfDecl(Decl, TemplateLoc);
 
     CanonType = Context.getTypeDeclType(Decl);
     assert(isa<RecordType>(CanonType) &&
            "type of non-dependent specialization is not a RecordType");
   } else if (auto *BTD = dyn_cast<BuiltinTemplateDecl>(Template)) {
-    CanonType = checkBuiltinTemplateIdType(*this, BTD, Converted, TemplateLoc,
-                                           TemplateArgs);
+    return checkBuiltinTemplateIdType(*this, SS, Name, BTD, Converted,
+                                      TemplateLoc, TemplateArgs);
   }
 
   // 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, CanonType);
+  return getResugaredTemplateSpecializationType(*this, SS.getScopeRep(), Name,
+                                                TemplateArgs, CanonType);
 }
 
 void Sema::ActOnUndeclaredTypeTemplateName(Scope *S, TemplateTy &ParsedName,
                                            TemplateNameKind &TNK,
                                            SourceLocation NameLoc,
                                            IdentifierInfo *&II) {
   assert(TNK == TNK_Undeclared_template && "not an undeclared template name");
 
if (Template.getAsAssumedTemplateName() &&
       resolveAssumedTemplateNameAsType(S, Template, TemplateIILoc))
     return true;
 
   // Translate the parser's template argument list in our AST format.
   TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
   translateTemplateArguments(TemplateArgsIn, TemplateArgs);
 
   if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
+    assert(SS.getScopeRep() == DTN->getQualifier());
+    resugarTemplateArguments(SS, TemplateArgs);
     QualType T
       = Context.getDependentTemplateSpecializationType(ETK_None,
                                                        DTN->getQualifier(),
                                                        DTN->getIdentifier(),
                                                        TemplateArgs);
     // Build type-source information.
     TypeLocBuilder TLB;
     DependentTemplateSpecializationTypeLoc SpecTL
       = TLB.push<DependentTemplateSpecializationTypeLoc>(T);
     SpecTL.setElaboratedKeywordLoc(SourceLocation());
     SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
     SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
     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 Result = CheckTemplateIdType(Template, TemplateIILoc, TemplateArgs);
-  if (Result.isNull())
+  QualType T = CheckTemplateIdType(SS, Template, TemplateIILoc, TemplateArgs);
+  if (T.isNull())
     return true;
 
   // Build type-source information.
   TypeLocBuilder TLB;
-  TemplateSpecializationTypeLoc SpecTL
-    = TLB.push<TemplateSpecializationTypeLoc>(Result);
+  TemplateSpecializationTypeLoc SpecTL =
+      TLB.push<TemplateSpecializationTypeLoc>(T);
   SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
   SpecTL.setTemplateNameLoc(TemplateIILoc);
   SpecTL.setLAngleLoc(LAngleLoc);
   SpecTL.setRAngleLoc(RAngleLoc);
   for (unsigned i = 0, e = SpecTL.getNumArgs(); i != e; ++i)
     SpecTL.setArgLocInfo(i, TemplateArgs[i].getLocInfo());
 
   // NOTE: avoid constructing an ElaboratedTypeLoc if this is a
   // constructor or destructor name (in such a case, the scope specifier
   // will be attached to the enclosing Decl or Expr node).
   if (SS.isNotEmpty() && !IsCtorOrDtorName) {
-    // Create an elaborated-type-specifier containing the nested-name-specifier.
-    Result = Context.getElaboratedType(ETK_None, SS.getScopeRep(), Result);
-    ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(Result);
+    T = Context.getElaboratedType(ETK_None, SS.getScopeRep(), T);
+    ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(T);
     ElabTL.setElaboratedKeywordLoc(SourceLocation());
     ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
   }
-
-  return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
+  return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T));
 }
 
 TypeResult Sema::ActOnTagTemplateIdType(TagUseKind TUK,
                                         TypeSpecifierType TagSpec,
                                         SourceLocation TagLoc,
                                         CXXScopeSpec &SS,
                                         SourceLocation TemplateKWLoc,
                                         TemplateTy TemplateD,
TypeResult Sema::ActOnTagTemplateIdType(TagUseKind TUK,
   translateTemplateArguments(TemplateArgsIn, TemplateArgs);
 
   // Determine the tag kind
   TagTypeKind TagKind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
   ElaboratedTypeKeyword Keyword
     = TypeWithKeyword::getKeywordForTagTypeKind(TagKind);
 
   if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
+    assert(SS.getScopeRep() == DTN->getQualifier());
+    resugarTemplateArguments(SS, TemplateArgs);
     QualType T = Context.getDependentTemplateSpecializationType(Keyword,
                                                           DTN->getQualifier(),
                                                           DTN->getIdentifier(),
                                                                 TemplateArgs);
 
     // Build type-source information.
     TypeLocBuilder TLB;
     DependentTemplateSpecializationTypeLoc SpecTL
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);
TemplateNameKind Sema::ActOnTemplateName(Scope *S,
   // rather than building a dependent template name that can never be valid.
   Diag(Name.getBeginLoc(),
        diag::err_template_kw_refers_to_dependent_non_template)
       << GetNameFromUnqualifiedId(Name).getName() << Name.getSourceRange()
       << TemplateKWLoc.isValid() << TemplateKWLoc;
   return TNK_Non_template;
 }
 
-bool Sema::CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,
-                                     TemplateArgumentLoc &AL,
-                          SmallVectorImpl<TemplateArgument> &Converted) {
+bool Sema::CheckTemplateTypeArgument(
+    TemplateTypeParmDecl *Param, TemplateArgumentLoc &AL,
+    SmallVectorImpl<TemplateArgument> &Converted, bool DontCanonicalize) {
   const TemplateArgument &Arg = AL.getArgument();
   QualType ArgType;
   TypeSourceInfo *TSI = nullptr;
 
   // Check template type parameter.
   switch(Arg.getKind()) {
   case TemplateArgument::Type:
     // C++ [temp.arg.type]p1:
default: {
     return true;
   }
   }
 
   if (CheckTemplateArgument(TSI))
     return true;
 
   // Add the converted template type argument.
+  if (!DontCanonicalize)
     ArgType = Context.getCanonicalType(ArgType);
 
   // Objective-C ARC:
   //   If an explicitly-specified template argument type is a lifetime type
   //   with no lifetime qualifier, the __strong lifetime qualifier is inferred.
   if (getLangOpts().ObjCAutoRefCount &&
       ArgType->isObjCLifetimeType() &&
       !ArgType.getObjCLifetime()) {
     Qualifiers Qs;

 ///
 /// \param Converted The checked, converted argument will be added to the
 /// end of this small vector.
 ///
 /// \param CTAK Describes how we arrived at this particular template argument:
 /// explicitly written, deduced, etc.
 ///
 /// \returns true on error, false otherwise.
-bool Sema::CheckTemplateArgument(NamedDecl *Param,
-                                 TemplateArgumentLoc &Arg,
-                                 NamedDecl *Template,
-                                 SourceLocation TemplateLoc,
-                                 SourceLocation RAngleLoc,
-                                 unsigned ArgumentPackIndex,
-                            SmallVectorImpl<TemplateArgument> &Converted,
-                                 CheckTemplateArgumentKind CTAK) {
+bool Sema::CheckTemplateArgument(
+    NamedDecl *Param, TemplateArgumentLoc &Arg, NamedDecl *Template,
+    SourceLocation TemplateLoc, SourceLocation RAngleLoc,
+    unsigned ArgumentPackIndex, SmallVectorImpl<TemplateArgument> &Converted,
+    CheckTemplateArgumentKind CTAK, bool DontCanonizalize) {
   // Check template type parameters.
   if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
-    return CheckTemplateTypeArgument(TTP, Arg, Converted);
+    return CheckTemplateTypeArgument(TTP, Arg, Converted, DontCanonizalize);
 
   // Check non-type template parameters.
   if (NonTypeTemplateParmDecl *NTTP =dyn_cast<NonTypeTemplateParmDecl>(Param)) {
     // Do substitution on the type of the non-type template parameter
     // with the template arguments we've seen thus far.  But if the
     // template has a dependent context then we cannot substitute yet.
     QualType NTTPType = NTTP->getType();
     if (NTTP->isParameterPack() && NTTP->isExpandedParameterPack())
if (NTTPType->isInstantiationDependentType() &&
         return true;
     }
 
     switch (Arg.getArgument().getKind()) {
     case TemplateArgument::Null:
       llvm_unreachable("Should never see a NULL template argument here");
 
     case TemplateArgument::Expression: {
+      Expr *E = Arg.getArgument().getAsExpr();
+      // FIXME: Workaround for double conversion
+      if (isa<ConstantExpr>(E)) {
+        Converted.push_back(Arg.getArgument());
+        break;
+      }
       TemplateArgument Result;
       unsigned CurSFINAEErrors = NumSFINAEErrors;
-      ExprResult Res =
-        CheckTemplateArgument(NTTP, NTTPType, Arg.getArgument().getAsExpr(),
-                              Result, CTAK);
+      ExprResult Res = CheckTemplateArgument(NTTP, NTTPType, E, Result, CTAK,
+                                             DontCanonizalize);
       if (Res.isInvalid())
         return true;
       // If the current template argument causes an error, give up now.
       if (CurSFINAEErrors < NumSFINAEErrors)
         return true;
 
       // If the resulting expression is new, then use it in place of the
       // old expression in the template argument.
case TemplateArgument::TemplateExpansion:
         // pack expansion expression.
         if (Arg.getArgument().getKind() == TemplateArgument::TemplateExpansion){
           E = ActOnPackExpansion(E.get(), Arg.getTemplateEllipsisLoc());
           if (E.isInvalid())
             return true;
         }
 
         TemplateArgument Result;
-        E = CheckTemplateArgument(NTTP, NTTPType, E.get(), Result);
+        E = CheckTemplateArgument(NTTP, NTTPType, E.get(), Result,
+                                  CTAK_Specified, DontCanonizalize);
         if (E.isInvalid())
           return true;
 
         Converted.push_back(Result);
         break;
       }
 
       // We have a template argument that actually does refer to a class

 }
 
 /// Check that the given template argument list is well-formed
 /// for specializing the given template.
 bool Sema::CheckTemplateArgumentList(
     TemplateDecl *Template, SourceLocation TemplateLoc,
     TemplateArgumentListInfo &TemplateArgs, bool PartialTemplateArgs,
     SmallVectorImpl<TemplateArgument> &Converted,
-    bool UpdateArgsWithConversions, bool *ConstraintsNotSatisfied) {
+    bool UpdateArgsWithConversions, bool *ConstraintsNotSatisfied,
+    bool DontCanonicalize) {
 
   if (ConstraintsNotSatisfied)
     *ConstraintsNotSatisfied = false;
 
   // Make a copy of the template arguments for processing.  Only make the
   // changes at the end when successful in matching the arguments to the
   // template.
   TemplateArgumentListInfo NewArgs = TemplateArgs;
if (Optional<unsigned> Expansions = getExpandedPackSize(*Param)) {
         Diag(Template->getLocation(), diag::note_template_decl_here)
           << Params->getSourceRange();
         return true;
       }
     }
 
     if (ArgIdx < NumArgs) {
       // Check the template argument we were given.
-      if (CheckTemplateArgument(*Param, NewArgs[ArgIdx], Template,
-                                TemplateLoc, RAngleLoc,
-                                ArgumentPack.size(), Converted))
+      if (CheckTemplateArgument(*Param, NewArgs[ArgIdx], Template, TemplateLoc,
+                                RAngleLoc, ArgumentPack.size(), Converted,
+                                CTAK_Specified, DontCanonicalize))
         return true;
 
       bool PackExpansionIntoNonPack =
           NewArgs[ArgIdx].getArgument().isPackExpansion() &&
           (!(*Param)->isTemplateParameterPack() || getExpandedPackSize(*Param));
       if (PackExpansionIntoNonPack && (isa<TypeAliasTemplateDecl>(Template) ||
                                        isa<ConceptDecl>(Template))) {
         // Core issue 1430: we have a pack expansion as an argument to an
for (TemplateParameterList::iterator Param = Params->begin(),
     // template here, we just create this object to put a note into the
     // context stack.
     InstantiatingTemplate Inst(*this, RAngleLoc, Template, *Param, Converted,
                                SourceRange(TemplateLoc, RAngleLoc));
     if (Inst.isInvalid())
       return true;
 
     // Check the default template argument.
-    if (CheckTemplateArgument(*Param, Arg, Template, TemplateLoc,
-                              RAngleLoc, 0, Converted))
+    if (CheckTemplateArgument(*Param, Arg, Template, TemplateLoc, RAngleLoc, 0,
+                              Converted, CTAK_Specified, DontCanonicalize))
       return true;
 
     // Core issue 150 (assumed resolution): if this is a template template
     // parameter, keep track of the default template arguments from the
     // template definition.
     if (isTemplateTemplateParameter)
       NewArgs.addArgument(Arg);
 
if (ParamType->isPointerType() &&
     }
   }
 
   return false;
 }
 
 /// Checks whether the given template argument is the address
 /// of an object or function according to C++ [temp.arg.nontype]p1.
-static bool
-CheckTemplateArgumentAddressOfObjectOrFunction(Sema &S,
-                                               NonTypeTemplateParmDecl *Param,
-                                               QualType ParamType,
-                                               Expr *ArgIn,
-                                               TemplateArgument &Converted) {
+static bool CheckTemplateArgumentAddressOfObjectOrFunction(
+    Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn,
+    TemplateArgument &Converted, bool DontCanonicalize) {
   bool Invalid = false;
   Expr *Arg = ArgIn;
   QualType ArgType = Arg->getType();
 
   bool AddressTaken = false;
   SourceLocation AddrOpLoc;
   if (S.getLangOpts().MicrosoftExt) {
     // Microsoft Visual C++ strips all casts, allows an arbitrary number of
else if (CXXUuidofExpr *CUE = dyn_cast<CXXUuidofExpr>(Arg))
     Entity = CUE->getGuidDecl();
 
   // If our parameter has pointer type, check for a null template value.
   if (ParamType->isPointerType() || ParamType->isNullPtrType()) {
     switch (isNullPointerValueTemplateArgument(S, Param, ParamType, ArgIn,
                                                Entity)) {
     case NPV_NullPointer:
       S.Diag(Arg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
-      Converted = TemplateArgument(S.Context.getCanonicalType(ParamType),
-                                   /*isNullPtr=*/true);
+      Converted = TemplateArgument(
+          DontCanonicalize ? ParamType : S.Context.getCanonicalType(ParamType),
       return false;
 
     case NPV_Error:
       return true;
 
     case NPV_NotNullPointer:
       break;
     }
if (!AddressTaken && ParamType->isPointerType()) {
     }
   }
 
   if (CheckTemplateArgumentIsCompatibleWithParameter(S, Param, ParamType, ArgIn,
                                                      Arg, ArgType))
     return true;
 
   // Create the template argument.
-  Converted = TemplateArgument(cast<ValueDecl>(Entity->getCanonicalDecl()),
-                               S.Context.getCanonicalType(ParamType));
+  Converted = TemplateArgument(
+      cast<ValueDecl>(DontCanonicalize ? Entity : Entity->getCanonicalDecl()),
+      DontCanonicalize ? ParamType : S.Context.getCanonicalType(ParamType));
   S.MarkAnyDeclReferenced(Arg->getBeginLoc(), Entity, false);
   return false;
 }
 
 /// Checks whether the given template argument is a pointer to
 /// member constant according to C++ [temp.arg.nontype]p1.
-static bool CheckTemplateArgumentPointerToMember(Sema &S,
-                                                 NonTypeTemplateParmDecl *Param,
-                                                 QualType ParamType,
-                                                 Expr *&ResultArg,
-                                                 TemplateArgument &Converted) {
+static bool CheckTemplateArgumentPointerToMember(
+    Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType,
+    Expr *&ResultArg, TemplateArgument &Converted, bool DontCanonicalize) {
   bool Invalid = false;
 
   Expr *Arg = ResultArg;
   bool ObjCLifetimeConversion;
 
   // C++ [temp.arg.nontype]p1:
   //
   //   A template-argument for a non-type, non-template
static bool CheckTemplateArgumentPointerToMember(
   // A constant of pointer-to-member type.
   else if ((DRE = dyn_cast<DeclRefExpr>(Arg))) {
     ValueDecl *VD = DRE->getDecl();
     if (VD->getType()->isMemberPointerType()) {
       if (isa<NonTypeTemplateParmDecl>(VD)) {
         if (Arg->isTypeDependent() || Arg->isValueDependent()) {
           Converted = TemplateArgument(Arg);
         } else {
-          VD = cast<ValueDecl>(VD->getCanonicalDecl());
-          Converted = TemplateArgument(VD, ParamType);
+          Converted = TemplateArgument(
+              cast<ValueDecl>(DontCanonicalize ? VD : VD->getCanonicalDecl()),
+              DontCanonicalize ? ParamType
+                               : S.Context.getCanonicalType(ParamType));
         }
         return Invalid;
       }
     }
 
     DRE = nullptr;
   }
 
   ValueDecl *Entity = DRE ? DRE->getDecl() : nullptr;
 
   // Check for a null pointer value.
   switch (isNullPointerValueTemplateArgument(S, Param, ParamType, ResultArg,
                                              Entity)) {
   case NPV_Error:
     return true;
   case NPV_NullPointer:
     S.Diag(ResultArg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
-    Converted = TemplateArgument(S.Context.getCanonicalType(ParamType),
-                                 /*isNullPtr*/true);
+    Converted = TemplateArgument(
+        DontCanonicalize ? ParamType : S.Context.getCanonicalType(ParamType),
+        /*isNullPtr*/ true);
     return false;
   case NPV_NotNullPointer:
     break;
   }
 
   if (S.IsQualificationConversion(ResultArg->getType(),
                                   ParamType.getNonReferenceType(), false,
                                   ObjCLifetimeConversion)) {
assert((isa<FieldDecl>(DRE->getDecl()) ||
             !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) &&
            "Only non-static member pointers can make it here");
 
     // Okay: this is the address of a non-static member, and therefore
     // a member pointer constant.
     if (Arg->isTypeDependent() || Arg->isValueDependent()) {
       Converted = TemplateArgument(Arg);
     } else {
-      ValueDecl *D = cast<ValueDecl>(DRE->getDecl()->getCanonicalDecl());
-      Converted = TemplateArgument(D, S.Context.getCanonicalType(ParamType));
+      ValueDecl *D = DRE->getDecl();
+      Converted = TemplateArgument(
+          DontCanonicalize ? D : cast<ValueDecl>(D->getCanonicalDecl()),
+          DontCanonicalize ? ParamType : S.Context.getCanonicalType(ParamType));
     }
     return Invalid;
   }
 
   // We found something else, but we don't know specifically what it is.
   S.Diag(Arg->getBeginLoc(), diag::err_template_arg_not_pointer_to_member_form)
       << Arg->getSourceRange();
   S.Diag(DRE->getDecl()->getLocation(), diag::note_template_arg_refers_here);
   return true;
 }
 
 /// Check a template argument against its corresponding
 /// non-type template parameter.
 ///
 /// This routine implements the semantics of C++ [temp.arg.nontype].
 /// If an error occurred, it returns ExprError(); otherwise, it
 /// returns the converted template argument. \p ParamType is the
 /// type of the non-type template parameter after it has been instantiated.
 ExprResult Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
                                        QualType ParamType, Expr *Arg,
                                        TemplateArgument &Converted,
-                                       CheckTemplateArgumentKind CTAK) {
+                                       CheckTemplateArgumentKind CTAK,
+                                       bool DontCanonicalize) {
   SourceLocation StartLoc = Arg->getBeginLoc();
 
   // If the parameter type somehow involves auto, deduce the type now.
   DeducedType *DeducedT = ParamType->getContainedDeducedType();
   if (getLangOpts().CPlusPlus17 && DeducedT && !DeducedT->isDeduced()) {
     // During template argument deduction, we allow 'decltype(auto)' to
     // match an arbitrary dependent argument.
     // FIXME: The language rules don't say what happens in this case.
if (getLangOpts().CPlusPlus17) {
     //
     // Similarly, don't inject a call to a copy constructor when initializing
     // from a template parameter of the same type.
     Expr *InnerArg = Arg->IgnoreParenImpCasts();
     if (ParamType->isRecordType() && isa<DeclRefExpr>(InnerArg) &&
         Context.hasSameUnqualifiedType(ParamType, InnerArg->getType())) {
       NamedDecl *ND = cast<DeclRefExpr>(InnerArg)->getDecl();
       if (auto *TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {
-        Converted = TemplateArgument(TPO, CanonParamType);
+        Converted = TemplateArgument(TPO, DontCanonicalize ? ParamType
+                                                           : CanonParamType);
         return Arg;
       }
       if (isa<NonTypeTemplateParmDecl>(ND)) {
         Converted = TemplateArgument(Arg);
         return Arg;
       }
     }
 
if (ArgResult.get()->isValueDependent()) {
       Converted = TemplateArgument(ArgResult.get());
       return ArgResult;
     }
 
     // Convert the APValue to a TemplateArgument.
     switch (Value.getKind()) {
     case APValue::None:
       assert(ParamType->isNullPtrType());
-      Converted = TemplateArgument(CanonParamType, /*isNullPtr*/true);
+      Converted = TemplateArgument(
+          DontCanonicalize ? ParamType : CanonParamType, /*isNullPtr*/ true);
       break;
     case APValue::Indeterminate:
       llvm_unreachable("result of constant evaluation should be initialized");
       break;
     case APValue::Int:
       assert(ParamType->isIntegralOrEnumerationType());
-      Converted = TemplateArgument(Context, Value.getInt(), CanonParamType);
+      Converted =
+          TemplateArgument(Context, Value.getInt(),
+                           DontCanonicalize ? ParamType : CanonParamType);
       break;
     case APValue::MemberPointer: {
       assert(ParamType->isMemberPointerType());
 
       // FIXME: We need TemplateArgument representation and mangling for these.
       if (!Value.getMemberPointerPath().empty()) {
         Diag(Arg->getBeginLoc(),
              diag::err_template_arg_member_ptr_base_derived_not_supported)
             << Value.getMemberPointerDecl() << ParamType
             << Arg->getSourceRange();
         return ExprError();
       }
 
+      QualType T = DontCanonicalize ? ParamType : CanonParamType;
       auto *VD = const_cast<ValueDecl*>(Value.getMemberPointerDecl());
-      Converted = VD ? TemplateArgument(VD, CanonParamType)
-                     : TemplateArgument(CanonParamType, /*isNullPtr*/true);
+      Converted = VD ? TemplateArgument(VD, T)
+                     : TemplateArgument(T, /*isNullPtr=*/true);
       break;
     }
     case APValue::LValue: {
       //   For a non-type template-parameter of pointer or reference type,
       //   the value of the constant expression shall not refer to
       assert(ParamType->isPointerType() || ParamType->isReferenceType() ||
              ParamType->isNullPtrType());
       // -- a temporary object
case APValue::LValue: {
         Diag(StartLoc, diag::err_non_type_template_arg_subobject)
           << Value.getAsString(Context, ParamType);
         return ExprError();
       }
       assert((VD || !ParamType->isReferenceType()) &&
              "null reference should not be a constant expression");
       assert((!VD || !ParamType->isNullPtrType()) &&
              "non-null value of type nullptr_t?");
-      Converted = VD ? TemplateArgument(VD, CanonParamType)
-                     : TemplateArgument(CanonParamType, /*isNullPtr*/true);
+      QualType T = DontCanonicalize ? ParamType : CanonParamType;
+      Converted = VD ? TemplateArgument(VD, T)
+                     : TemplateArgument(T, /*isNullPtr=*/true);
       break;
     }
     case APValue::Struct:
-    case APValue::Union:
+    case APValue::Union: {
       // Get or create the corresponding template parameter object.
-      Converted = TemplateArgument(
-          Context.getTemplateParamObjectDecl(CanonParamType, Value),
-          CanonParamType);
+      QualType T = DontCanonicalize ? ParamType : CanonParamType;
+      Converted =
+          TemplateArgument(Context.getTemplateParamObjectDecl(T, Value), T);
       break;
+    }
     case APValue::AddrLabelDiff:
       return Diag(StartLoc, diag::err_non_type_template_arg_addr_label_diff);
     case APValue::FixedPoint:
     case APValue::Float:
     case APValue::ComplexInt:
     case APValue::ComplexFloat:
     case APValue::Vector:
     case APValue::Array:
if (getLangOpts().CPlusPlus11) {
       // that case, this may extend the argument from 1 bit to 8 bits.
       QualType IntegerType = ParamType;
       if (const EnumType *Enum = IntegerType->getAs<EnumType>())
         IntegerType = Enum->getDecl()->getIntegerType();
       Value = Value.extOrTrunc(IntegerType->isBitIntType()
                                    ? Context.getIntWidth(IntegerType)
                                    : Context.getTypeSize(IntegerType));
 
-      Converted = TemplateArgument(Context, Value,
-                                   Context.getCanonicalType(ParamType));
+      Converted = TemplateArgument(
+          Context, Value,
+          DontCanonicalize ? ParamType : Context.getCanonicalType(ParamType));
       return ArgResult;
     }
 
     ExprResult ArgResult = DefaultLvalueConversion(Arg);
     if (ArgResult.isInvalid())
       return ExprError();
     Arg = ArgResult.get();
 
if (ParamType->isIntegralOrEnumerationType()) {
     // parameter.
     if (Arg->isValueDependent()) {
       // The argument is value-dependent. Create a new
       // TemplateArgument with the converted expression.
       Converted = TemplateArgument(Arg);
       return Arg;
     }
 
-    QualType IntegerType = Context.getCanonicalType(ParamType);
-    if (const EnumType *Enum = IntegerType->getAs<EnumType>())
-      IntegerType = Context.getCanonicalType(Enum->getDecl()->getIntegerType());
+    QualType IntegerType =
+        DontCanonicalize ? ParamType : Context.getCanonicalType(ParamType);
+    if (const EnumType *Enum = IntegerType->getAs<EnumType>()) {
+      IntegerType = Enum->getDecl()->getIntegerType();
+      if (!DontCanonicalize)
+        IntegerType = Context.getCanonicalType(IntegerType);
+    }
 
     if (ParamType->isBooleanType()) {
       // Value must be zero or one.
       Value = Value != 0;
       unsigned AllowedBits = Context.getTypeSize(IntegerType);
       if (Value.getBitWidth() != AllowedBits)
         Value = Value.extOrTrunc(AllowedBits);
       Value.setIsSigned(IntegerType->isSignedIntegerOrEnumerationType());
if (ParamType->isBooleanType()) {
       if (RequiredBits > AllowedBits) {
         Diag(Arg->getBeginLoc(), diag::warn_template_arg_too_large)
             << toString(OldValue, 10) << toString(Value, 10) << Param->getType()
             << Arg->getSourceRange();
         Diag(Param->getLocation(), diag::note_template_param_here);
       }
     }
 
+    QualType T =
+        DontCanonicalize ? ParamType : Context.getCanonicalType(ParamType);
     Converted = TemplateArgument(Context, Value,
-                                 ParamType->isEnumeralType()
-                                   ? Context.getCanonicalType(ParamType)
-                                   : IntegerType);
+                                 ParamType->isEnumeralType() ? T : IntegerType);
     return Arg;
   }
 
   QualType ArgType = Arg->getType();
   DeclAccessPair FoundResult; // temporary for ResolveOverloadedFunction
 
   // Handle pointer-to-function, reference-to-function, and
   // pointer-to-member-function all in (roughly) the same way.
if (// -- For a non-type template-parameter of type pointer to
 
     if (Arg->getType() == Context.OverloadTy) {
       if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg, ParamType,
                                                                 true,
                                                                 FoundResult)) {
         if (DiagnoseUseOfDecl(Fn, Arg->getBeginLoc()))
           return ExprError();
 
-        Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
+        // FIXME: resugar
+        Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn, nullptr);
         ArgType = Arg->getType();
       } else
         return ExprError();
     }
 
     if (!ParamType->isMemberPointerType()) {
-      if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param,
-                                                         ParamType,
-                                                         Arg, Converted))
+      if (CheckTemplateArgumentAddressOfObjectOrFunction(
+              *this, Param, ParamType, Arg, Converted, DontCanonicalize))
         return ExprError();
       return Arg;
     }
 
     if (CheckTemplateArgumentPointerToMember(*this, Param, ParamType, Arg,
-                                             Converted))
+                                             Converted, DontCanonicalize))
       return ExprError();
     return Arg;
   }
 
   if (ParamType->isPointerType()) {
     //   -- for a non-type template-parameter of type pointer to
     //      object, qualification conversions (4.4) and the
     //      array-to-pointer conversion (4.2) are applied.
     // C++0x also allows a value of std::nullptr_t.
     assert(ParamType->getPointeeType()->isIncompleteOrObjectType() &&
            "Only object pointers allowed here");
 
-    if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param,
-                                                       ParamType,
-                                                       Arg, Converted))
+    if (CheckTemplateArgumentAddressOfObjectOrFunction(
+            *this, Param, ParamType, Arg, Converted, DontCanonicalize))
       return ExprError();
     return Arg;
   }
 
   if (const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>()) {
     //   -- For a non-type template-parameter of type reference to
     //      object, no conversions apply. The type referred to by the
     //      reference may be more cv-qualified than the (otherwise
     //      identical) type of the template-argument. The
     //      template-parameter is bound directly to the
     //      template-argument, which must be an lvalue.
     assert(ParamRefType->getPointeeType()->isIncompleteOrObjectType() &&
            "Only object references allowed here");
 
     if (Arg->getType() == Context.OverloadTy) {
       if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg,
                                                  ParamRefType->getPointeeType(),
                                                                 true,
                                                                 FoundResult)) {
         if (DiagnoseUseOfDecl(Fn, Arg->getBeginLoc()))
           return ExprError();
 
-        Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
+        // FIXME: resugar
+        Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn, nullptr);
         ArgType = Arg->getType();
       } else
         return ExprError();
     }
 
-    if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param,
-                                                       ParamType,
-                                                       Arg, Converted))
+    if (CheckTemplateArgumentAddressOfObjectOrFunction(
+            *this, Param, ParamType, Arg, Converted, DontCanonicalize))
       return ExprError();
     return Arg;
   }
 
   // Deal with parameters of type std::nullptr_t.
   if (ParamType->isNullPtrType()) {
     if (Arg->isTypeDependent() || Arg->isValueDependent()) {
       Converted = TemplateArgument(Arg);
       return Arg;
     }
 
     switch (isNullPointerValueTemplateArgument(*this, Param, ParamType, Arg)) {
     case NPV_NotNullPointer:
       Diag(Arg->getExprLoc(), diag::err_template_arg_not_convertible)
         << Arg->getType() << ParamType;
       Diag(Param->getLocation(), diag::note_template_param_here);
       return ExprError();
 
     case NPV_Error:
       return ExprError();
 
     case NPV_NullPointer:
       Diag(Arg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
-      Converted = TemplateArgument(Context.getCanonicalType(ParamType),
-                                   /*isNullPtr*/true);
+      Converted = TemplateArgument(
+          DontCanonicalize ? ParamType : Context.getCanonicalType(ParamType),
+          /*isNullPtr*/ true);
       return Arg;
     }
   }
 
   //     -- For a non-type template-parameter of type pointer to data
   //        member, qualification conversions (4.4) are applied.
   assert(ParamType->isMemberPointerType() && "Only pointers to members remain");
 
   if (CheckTemplateArgumentPointerToMember(*this, Param, ParamType, Arg,
-                                           Converted))
+                                           Converted, DontCanonicalize))
     return ExprError();
   return Arg;
 }
 
 static void DiagnoseTemplateParameterListArityMismatch(
     Sema &S, TemplateParameterList *New, TemplateParameterList *Old,
     Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc);
 
Diag(TypenameLoc,
          getLangOpts().CPlusPlus11 ?
            diag::warn_cxx98_compat_typename_outside_of_template :
            diag::ext_typename_outside_of_template)
       << FixItHint::CreateRemoval(TypenameLoc);
 
   // Strangely, non-type results are not ignored by this lookup, so the
   // program is ill-formed if it finds an injected-class-name.
   if (TypenameLoc.isValid()) {
-    auto *LookupRD =
+    const auto *LookupRD =
         dyn_cast_or_null<CXXRecordDecl>(computeDeclContext(SS, false));
     if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
       Diag(TemplateIILoc,
            diag::ext_out_of_line_qualified_id_type_names_constructor)
         << TemplateII << 0 /*injected-class-name used as template name*/
         << (TemplateKWLoc.isValid() ? 1 : 0 /*'template'/'typename' keyword*/);
     }
   }
 
   // Translate the parser's template argument list in our AST format.
   TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
   translateTemplateArguments(TemplateArgsIn, TemplateArgs);
 
   TemplateName Template = TemplateIn.get();
   if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
     // Construct a dependent template specialization type.
     assert(DTN && "dependent template has non-dependent name?");
     assert(DTN->getQualifier() == SS.getScopeRep());
+    resugarTemplateArguments(SS, TemplateArgs);
     QualType T = Context.getDependentTemplateSpecializationType(ETK_Typename,
                                                           DTN->getQualifier(),
                                                           DTN->getIdentifier(),
                                                                 TemplateArgs);
 
     // Create source-location information for this type.
     TypeLocBuilder Builder;
     DependentTemplateSpecializationTypeLoc SpecTL
     = Builder.push<DependentTemplateSpecializationTypeLoc>(T);
     SpecTL.setElaboratedKeywordLoc(TypenameLoc);
     SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
     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());
     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, /*NamedDecl=*/nullptr, /*Args=*/nullptr,
+                  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

 Sema::getIdentityTemplateArgumentLoc(NamedDecl *TemplateParm,
                                      SourceLocation Location) {
   return getTrivialTemplateArgumentLoc(
       Context.getInjectedTemplateArg(TemplateParm), QualType(), Location);
 }
 
 /// Convert the given deduced template argument and add it to the set of
 /// fully-converted template arguments.
-static bool
-ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param,
-                               DeducedTemplateArgument Arg,
-                               NamedDecl *Template,
-                               TemplateDeductionInfo &Info,
-                               bool IsDeduced,
-                               SmallVectorImpl<TemplateArgument> &Output) {
+static bool ConvertDeducedTemplateArgument(
+    Sema &S, NamedDecl *Param, DeducedTemplateArgument Arg, NamedDecl *Template,
+    TemplateDeductionInfo &Info, bool IsDeduced,
+    SmallVectorImpl<TemplateArgument> &Output, bool DontCanonicalize) {
   auto ConvertArg = [&](DeducedTemplateArgument Arg,
                         unsigned ArgumentPackIndex) {
     // Convert the deduced template argument into a template
     // argument that we can check, almost as if the user had written
     // the template argument explicitly.
     TemplateArgumentLoc ArgLoc =
         S.getTrivialTemplateArgumentLoc(Arg, QualType(), Info.getLocation());
 
     // Check the template argument, converting it as necessary.
     return S.CheckTemplateArgument(
         Param, ArgLoc, Template, Template->getLocation(),
         Template->getSourceRange().getEnd(), ArgumentPackIndex, Output,
         IsDeduced
             ? (Arg.wasDeducedFromArrayBound() ? Sema::CTAK_DeducedFromArrayBound
                                               : Sema::CTAK_Deduced)
-            : Sema::CTAK_Specified);
+            : Sema::CTAK_Specified,
+        DontCanonicalize);
   };
 
   if (Arg.getKind() == TemplateArgument::Pack) {
     // This is a template argument pack, so check each of its arguments against
     // the template parameter.
     SmallVector<TemplateArgument, 2> PackedArgsBuilder;
     for (const auto &P : Arg.pack_elements()) {
       // When converting the deduced template argument, append it to the
static bool ConvertDeducedTemplateArgument(
   }
 
   return ConvertArg(Arg, 0);
 }
 
 // FIXME: This should not be a template, but
 // ClassTemplatePartialSpecializationDecl sadly does not derive from
 // TemplateDecl.
-template<typename TemplateDeclT>
+template <typename TemplateDeclT>
 static Sema::TemplateDeductionResult ConvertDeducedTemplateArguments(
     Sema &S, TemplateDeclT *Template, bool IsDeduced,
     SmallVectorImpl<DeducedTemplateArgument> &Deduced,
     TemplateDeductionInfo &Info, SmallVectorImpl<TemplateArgument> &Builder,
     LocalInstantiationScope *CurrentInstantiationScope = nullptr,
-    unsigned NumAlreadyConverted = 0, bool PartialOverloading = false) {
+    unsigned NumAlreadyConverted = 0, bool PartialOverloading = false,
+    bool DontCanonicalize = false) {
   TemplateParameterList *TemplateParams = Template->getTemplateParameters();
 
   for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
     NamedDecl *Param = TemplateParams->getParam(I);
 
     // C++0x [temp.arg.explicit]p3:
     //    A trailing template parameter pack (14.5.3) not otherwise deduced will
     //    be deduced to an empty sequence of template arguments.
if (!Deduced[I].isNull()) {
           Builder.push_back(Deduced[I]);
           continue;
         }
       }
 
       // We may have deduced this argument, so it still needs to be
       // checked and converted.
       if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], Template, Info,
-                                         IsDeduced, Builder)) {
+                                         IsDeduced, Builder,
+                                         DontCanonicalize)) {
         Info.Param = makeTemplateParameter(Param);
         // FIXME: These template arguments are temporary. Free them!
         Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder));
         return Sema::TDK_SubstitutionFailure;
       }
 
       continue;
     }
if (DefArg.getArgument().isNull()) {
 
       return HasDefaultArg ? Sema::TDK_SubstitutionFailure
                            : Sema::TDK_Incomplete;
     }
 
     // Check whether we can actually use the default argument.
     if (S.CheckTemplateArgument(Param, DefArg, TD, TD->getLocation(),
                                 TD->getSourceRange().getEnd(), 0, Builder,
-                                Sema::CTAK_Specified)) {
+                                Sema::CTAK_Specified, DontCanonicalize)) {
       Info.Param = makeTemplateParameter(
                          const_cast<NamedDecl *>(TemplateParams->getParam(I)));
       // FIXME: These template arguments are temporary. Free them!
       Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder));
       return Sema::TDK_SubstitutionFailure;
     }
 
     // If we get here, we successfully used the default template argument.

 /// Complete template argument deduction for a partial specialization.
 template <typename T>
 static std::enable_if_t<IsPartialSpecialization<T>::value,
                         Sema::TemplateDeductionResult>
 FinishTemplateArgumentDeduction(
     Sema &S, T *Partial, bool IsPartialOrdering,
     const TemplateArgumentList &TemplateArgs,
     SmallVectorImpl<DeducedTemplateArgument> &Deduced,
-    TemplateDeductionInfo &Info) {
+    TemplateDeductionInfo &Info, bool DontCanonicalize) {
   // Unevaluated SFINAE context.
   EnterExpressionEvaluationContext Unevaluated(
       S, Sema::ExpressionEvaluationContext::Unevaluated);
   Sema::SFINAETrap Trap(S);
 
   Sema::ContextRAII SavedContext(S, getAsDeclContextOrEnclosing(Partial));
 
   // C++ [temp.deduct.type]p2:
   //   [...] or if any template argument remains neither deduced nor
   //   explicitly specified, template argument deduction fails.
   SmallVector<TemplateArgument, 4> Builder;
   if (auto Result = ConvertDeducedTemplateArguments(
-          S, Partial, IsPartialOrdering, Deduced, Info, Builder))
+          S, Partial, IsPartialOrdering, Deduced, Info, Builder,
+          /*CurrentInstantiationScope=*/nullptr,
+          /*NumAlreadyConverted=*/0U,
+          /*PartialOverloading=*/false, DontCanonicalize))
     return Result;
 
   // Form the template argument list from the deduced template arguments.
   TemplateArgumentList *DeducedArgumentList
     = TemplateArgumentList::CreateCopy(S.Context, Builder);
 
   Info.reset(DeducedArgumentList);
 
+  if (DontCanonicalize)
+    return Sema::TDK_Success;
+
   // Substitute the deduced template arguments into the template
   // arguments of the class template partial specialization, and
   // verify that the instantiated template arguments are both valid
   // and are equivalent to the template arguments originally provided
   // to the class template.
   LocalInstantiationScope InstScope(S);
   auto *Template = Partial->getSpecializedTemplate();
   const ASTTemplateArgumentListInfo *PartialTemplArgInfo =

 
 /// Complete template argument deduction for a class or variable template,
 /// when partial ordering against a partial specialization.
 // FIXME: Factor out duplication with partial specialization version above.
 static Sema::TemplateDeductionResult FinishTemplateArgumentDeduction(
     Sema &S, TemplateDecl *Template, bool PartialOrdering,
     const TemplateArgumentList &TemplateArgs,
     SmallVectorImpl<DeducedTemplateArgument> &Deduced,
-    TemplateDeductionInfo &Info) {
+    TemplateDeductionInfo &Info, bool DontCanonicalize) {
   // Unevaluated SFINAE context.
   EnterExpressionEvaluationContext Unevaluated(
       S, Sema::ExpressionEvaluationContext::Unevaluated);
   Sema::SFINAETrap Trap(S);
 
   Sema::ContextRAII SavedContext(S, getAsDeclContextOrEnclosing(Template));
 
   // C++ [temp.deduct.type]p2:
   //   [...] or if any template argument remains neither deduced nor
   //   explicitly specified, template argument deduction fails.
   SmallVector<TemplateArgument, 4> Builder;
   if (auto Result = ConvertDeducedTemplateArguments(
-          S, Template, /*IsDeduced*/PartialOrdering, Deduced, Info, Builder))
+          S, Template, /*IsDeduced*/ PartialOrdering, Deduced, Info, Builder,
+          /*CurrentInstantiationScope=*/nullptr,
+          /*NumAlreadyConverted=*/0U, /*PartialOverloading=*/false,
+          DontCanonicalize))
     return Result;
 
+  if (DontCanonicalize)
+    return Sema::TDK_Success;
+
   // Check that we produced the correct argument list.
   TemplateParameterList *TemplateParams = Template->getTemplateParameters();
   for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) {
     TemplateArgument InstArg = Builder[I];
     if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg,
                            /*PackExpansionMatchesPack*/true)) {
       Info.Param = makeTemplateParameter(TemplateParams->getParam(I));
       Info.FirstArg = TemplateArgs[I];

 }
 
 /// Perform template argument deduction to determine whether
 /// the given template arguments match the given class template
 /// partial specialization per C++ [temp.class.spec.match].
 Sema::TemplateDeductionResult
 Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
                               const TemplateArgumentList &TemplateArgs,
-                              TemplateDeductionInfo &Info) {
+                              TemplateDeductionInfo &Info,
+                              bool DontCanonicalize) {
   if (Partial->isInvalidDecl())
     return TDK_Invalid;
 
   // C++ [temp.class.spec.match]p2:
   //   A partial specialization matches a given actual template
   //   argument list if the template arguments of the partial
   //   specialization can be deduced from the actual template argument
   //   list (14.8.2).
Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
 
   if (Trap.hasErrorOccurred())
     return Sema::TDK_SubstitutionFailure;
 
   TemplateDeductionResult Result;
   runWithSufficientStackSpace(Info.getLocation(), [&] {
     Result = ::FinishTemplateArgumentDeduction(*this, Partial,
                                                /*IsPartialOrdering=*/false,
-                                               TemplateArgs, Deduced, Info);
+                                               TemplateArgs, Deduced, Info,
+                                               DontCanonicalize);
   });
   return Result;
 }
 
 /// Perform template argument deduction to determine whether
 /// the given template arguments match the given variable template
 /// partial specialization per C++ [temp.class.spec.match].
 Sema::TemplateDeductionResult
 Sema::DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial,
                               const TemplateArgumentList &TemplateArgs,
-                              TemplateDeductionInfo &Info) {
+                              TemplateDeductionInfo &Info,
+                              bool DontCanonicalize) {
   if (Partial->isInvalidDecl())
     return TDK_Invalid;
 
   // C++ [temp.class.spec.match]p2:
   //   A partial specialization matches a given actual template
   //   argument list if the template arguments of the partial
   //   specialization can be deduced from the actual template argument
   //   list (14.8.2).
Sema::DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial,
 
   if (Trap.hasErrorOccurred())
     return Sema::TDK_SubstitutionFailure;
 
   TemplateDeductionResult Result;
   runWithSufficientStackSpace(Info.getLocation(), [&] {
     Result = ::FinishTemplateArgumentDeduction(*this, Partial,
                                                /*IsPartialOrdering=*/false,
-                                               TemplateArgs, Deduced, Info);
+                                               TemplateArgs, Deduced, Info,
+                                               DontCanonicalize);
   });
   return Result;
 }
 
 /// Determine whether the given type T is a simple-template-id type.
 static bool isSimpleTemplateIdType(QualType T) {
   if (const TemplateSpecializationType *Spec
         = T->getAs<TemplateSpecializationType>())
Sema::TemplateDeductionResult Sema::FinishTemplateArgumentDeduction(
   }
 
   return TDK_Success;
 }
 
 /// Gets the type of a function for template-argument-deducton
 /// purposes when it's considered as part of an overload set.
 static QualType GetTypeOfFunction(Sema &S, const OverloadExpr::FindResult &R,
-                                  FunctionDecl *Fn) {
+                                  FunctionDecl *Fn,
+                                  const TemplateArgumentListInfo *Args) {
   // We may need to deduce the return type of the function now.
   if (S.getLangOpts().CPlusPlus14 && Fn->getReturnType()->isUndeducedType() &&
       S.DeduceReturnType(Fn, R.Expression->getExprLoc(), /*Diagnose*/ false))
     return {};
 
+  QualType FT = Fn->getType();
+  FT = S.resugar(CXXScopeSpec(), Fn, Args, FT, /*Escapes=*/true);
+
   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());
+      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,
                             Expr *Arg, QualType ParamType,
                             bool ParamWasReference) {
 
   OverloadExpr::FindResult R = OverloadExpr::find(Arg);
 
   OverloadExpr *Ovl = R.Expression;
 
   // C++0x [temp.deduct.call]p4
   unsigned TDF = 0;
   if (ParamWasReference)
     TDF |= TDF_ParamWithReferenceType;
   if (R.IsAddressOfOperand)
     TDF |= TDF_IgnoreQualifiers;
 
+  // Gather the explicit template arguments, if any.
+  TemplateArgumentListInfo ExplicitTemplateArgs;
+  if (Ovl->hasExplicitTemplateArgs())
+    Ovl->copyTemplateArgumentsInto(ExplicitTemplateArgs);
+
   // C++0x [temp.deduct.call]p6:
   //   When P is a function type, pointer to function type, or pointer
   //   to member function type:
 
   if (!ParamType->isFunctionType() &&
       !ParamType->isFunctionPointerType() &&
       !ParamType->isMemberFunctionPointerType()) {
     if (Ovl->hasExplicitTemplateArgs()) {
       // But we can still look for an explicit specialization.
-      if (FunctionDecl *ExplicitSpec
-            = S.ResolveSingleFunctionTemplateSpecialization(Ovl))
-        return GetTypeOfFunction(S, R, ExplicitSpec);
+      if (FunctionDecl *ExplicitSpec =
+              S.ResolveSingleFunctionTemplateSpecialization(
+                  Ovl, ExplicitTemplateArgs))
+        return GetTypeOfFunction(S, R, ExplicitSpec, &ExplicitTemplateArgs);
     }
 
     DeclAccessPair DAP;
     if (FunctionDecl *Viable =
             S.resolveAddressOfSingleOverloadCandidate(Arg, DAP))
-      return GetTypeOfFunction(S, R, Viable);
+      return GetTypeOfFunction(S, R, Viable, nullptr);
 
     return {};
   }
 
-  // Gather the explicit template arguments, if any.
-  TemplateArgumentListInfo ExplicitTemplateArgs;
-  if (Ovl->hasExplicitTemplateArgs())
-    Ovl->copyTemplateArgumentsInto(ExplicitTemplateArgs);
   QualType Match;
   for (UnresolvedSetIterator I = Ovl->decls_begin(),
          E = Ovl->decls_end(); I != E; ++I) {
     NamedDecl *D = (*I)->getUnderlyingDecl();
 
     if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) {
       //   - If the argument is an overload set containing one or more
       //     function templates, the parameter is treated as a
       //     non-deduced context.
       if (!Ovl->hasExplicitTemplateArgs())
         return {};
 
       // Otherwise, see if we can resolve a function type
       FunctionDecl *Specialization = nullptr;
       TemplateDeductionInfo Info(Ovl->getNameLoc());
       if (S.DeduceTemplateArguments(FunTmpl, &ExplicitTemplateArgs,
                                     Specialization, Info))
         continue;
 
       D = Specialization;
     }
 
     FunctionDecl *Fn = cast<FunctionDecl>(D);
-    QualType ArgType = GetTypeOfFunction(S, R, Fn);
+    QualType ArgType = GetTypeOfFunction(S, R, Fn, &ExplicitTemplateArgs);
     if (ArgType.isNull()) continue;
 
     // Function-to-pointer conversion.
     if (!ParamWasReference && ParamType->isPointerType() &&
         ArgType->isFunctionType())
       ArgType = S.Context.getPointerType(ArgType);
 
     //   - If the argument is an overload set (not containing function
Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result,
   DependentAuto DependentResult = {
       /*.IsPack = */ (bool)Type.getAs<PackExpansionTypeLoc>()};
 
   if (!DependentDeductionDepth &&
       (Type.getType()->isDependentType() || Init->isTypeDependent() ||
        Init->containsUnexpandedParameterPack())) {
     Result = SubstituteDeducedTypeTransform(*this, DependentResult).Apply(Type);
     assert(!Result.isNull() && "substituting DependentTy can't fail");
+    // Remove any substitution sugar.
+    // FIXME: might make sense to have SubstituteDeducedTypeTransform do this.
+    Result = resugarEscapes(Result);
     return DAR_Succeeded;
   }
 
   // Find the depth of template parameter to synthesize.
   unsigned Depth = DependentDeductionDepth.value_or(0);
 
   // If this is a 'decltype(auto)' specifier, do the decltype dance.
   // Since 'decltype(auto)' can only occur at the top of the type, we
if (AT->isDecltypeAuto()) {
                                                Type.getContainedAutoTypeLoc(),
                                                Deduced);
         if (ConstraintsResult != DAR_Succeeded)
           return ConstraintsResult;
       }
       Result = SubstituteDeducedTypeTransform(*this, Deduced).Apply(Type);
       if (Result.isNull())
         return DAR_FailedAlreadyDiagnosed;
+      // Remove any substitution sugar.
+      // FIXME: might make sense to have SubstituteDeducedTypeTransform do this.
+      Result = resugarEscapes(Result);
       return DAR_Succeeded;
     } else if (!getLangOpts().CPlusPlus) {
       if (isa<InitListExpr>(Init)) {
         Diag(Init->getBeginLoc(), diag::err_auto_init_list_from_c);
         return DAR_FailedAlreadyDiagnosed;
       }
     }
   }
Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result,
   // If deduction failed, don't diagnose if the initializer is dependent; it
   // might acquire a matching type in the instantiation.
   auto DeductionFailed = [&](TemplateDeductionResult TDK,
                              ArrayRef<SourceRange> Ranges) -> DeduceAutoResult {
     if (Init->isTypeDependent()) {
       Result =
           SubstituteDeducedTypeTransform(*this, DependentResult).Apply(Type);
       assert(!Result.isNull() && "substituting DependentTy can't fail");
+      // Remove any substitution sugar.
+      // FIXME: might make sense to have SubstituteDeducedTypeTransform do this.
+      Result = resugarEscapes(Result);
       return DAR_Succeeded;
     }
     if (diagnoseAutoDeductionFailure(*this, TDK, Info, Ranges))
       return DAR_FailedAlreadyDiagnosed;
     return DAR_Failed;
   };
 
   SmallVector<OriginalCallArg, 4> OriginalCallArgs;
if (AT->isConstrained() && !IgnoreConstraints) {
       if (ConstraintsResult != DAR_Succeeded)
         return ConstraintsResult;
     }
   }
 
   Result = SubstituteDeducedTypeTransform(*this, DeducedType).Apply(Type);
   if (Result.isNull())
     return DAR_FailedAlreadyDiagnosed;
+  // Remove any substitution sugar.
+  // FIXME: might make sense to have SubstituteDeducedTypeTransform do this.
+  Result = resugarEscapes(Result);
 
   // Check that the deduced argument type is compatible with the original
   // argument type per C++ [temp.deduct.call]p4.
   QualType DeducedA = InitList ? Deduced[0].getAsType() : Result;
   for (const OriginalCallArg &OriginalArg : OriginalCallArgs) {
     assert((bool)InitList == OriginalArg.DecomposedParam &&
            "decomposed non-init-list in auto deduction?");
     if (auto TDK =
static bool isAtLeastAsSpecializedAs(Sema &S, QualType T1, QualType T2,
 
   auto *TST1 = T1->castAs<TemplateSpecializationType>();
   bool AtLeastAsSpecialized;
   S.runWithSufficientStackSpace(Info.getLocation(), [&] {
     AtLeastAsSpecialized = !FinishTemplateArgumentDeduction(
         S, P2, /*IsPartialOrdering=*/true,
         TemplateArgumentList(TemplateArgumentList::OnStack,
                              TST1->template_arguments()),
-        Deduced, Info);
+        Deduced, Info,
+        /*DontCanonicalize=*/false); // FIXME
   });
   return AtLeastAsSpecialized;
 }
 
 /// Returns the more specialized class template partial specialization
 /// according to the rules of partial ordering of class template partial
 /// specializations (C++ [temp.class.order]).
 ///

clang/lib/Sema/SemaTemplateInstantiate.cpp

getPackSubstitutedTemplateArgument(Sema &S, TemplateArgument Arg) {
   if (Arg.isPackExpansion())
     Arg = Arg.getPackExpansionPattern();
   return Arg;
 }
 
 Decl *TemplateInstantiator::TransformDecl(SourceLocation Loc, Decl *D) {
   if (!D)
     return nullptr;
+  Decl *TransD =
+      SemaRef.FindInstantiatedDecl(Loc, cast<NamedDecl>(D), TemplateArgs);
+  if (!TransD)
+    return nullptr;
 
-  if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(D)) {
+  if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(D))
     if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
       // If the corresponding template argument is NULL or non-existent, it's
       // because we are performing instantiation from explicitly-specified
       // template arguments in a function template, but there were some
       // arguments left unspecified.
       if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
                                             TTP->getPosition()))
-        return D;
+        return TransD;
 
       TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
 
       if (TTP->isParameterPack()) {
         assert(Arg.getKind() == TemplateArgument::Pack &&
                "Missing argument pack");
         Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
       }
 
       TemplateName Template = Arg.getAsTemplate().getNameToSubstitute();
       assert(!Template.isNull() && Template.getAsTemplateDecl() &&
              "Wrong kind of template template argument");
       return Template.getAsTemplateDecl();
     }
-
-    // Fall through to find the instantiated declaration for this template
-    // template parameter.
-  }
-
-  return SemaRef.FindInstantiatedDecl(Loc, cast<NamedDecl>(D), TemplateArgs);
+  return TransD;
 }
 
 Decl *TemplateInstantiator::TransformDefinition(SourceLocation Loc, Decl *D) {
   Decl *Inst = getSema().SubstDecl(D, getSema().CurContext, TemplateArgs);
   if (!Inst)
     return nullptr;
 
   getSema().CurrentInstantiationScope->InstantiatedLocal(D, Inst);
TemplateInstantiator::RebuildElaboratedType(SourceLocation KeywordLoc,
 
   return inherited::RebuildElaboratedType(KeywordLoc, Keyword, QualifierLoc, T);
 }
 
 TemplateName TemplateInstantiator::TransformTemplateName(
     CXXScopeSpec &SS, TemplateName Name, SourceLocation NameLoc,
     QualType ObjectType, NamedDecl *FirstQualifierInScope,
     bool AllowInjectedClassName) {
-  if (TemplateTemplateParmDecl *TTP
-       = dyn_cast_or_null<TemplateTemplateParmDecl>(Name.getAsTemplateDecl())) {
-    if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
-      // If the corresponding template argument is NULL or non-existent, it's
-      // because we are performing instantiation from explicitly-specified
-      // template arguments in a function template, but there were some
-      // arguments left unspecified.
-      if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
-                                            TTP->getPosition()))
-        return Name;
+  if (auto *TTP = dyn_cast_or_null<TemplateTemplateParmDecl>(
+          Name.getAsTemplateDecl())) {
+
+    auto *TransTTP = cast<TemplateTemplateParmDecl>(
+        SemaRef.FindInstantiatedDecl(NameLoc, TTP, TemplateArgs));
+
+    if (TTP->getDepth() >= TemplateArgs.getNumLevels())
+      return TemplateName(TransTTP);
+
+    if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(), TTP->getPosition()))
 
-      TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
 
-      if (TemplateArgs.isRewrite()) {
-        // We're rewriting the template parameter as a reference to another
-        // template parameter.
-        if (Arg.getKind() == TemplateArgument::Pack) {
-          assert(Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() &&
-                 "unexpected pack arguments in template rewrite");
-          Arg = Arg.pack_begin()->getPackExpansionPattern();
-        }
-        assert(Arg.getKind() == TemplateArgument::Template &&
-               "unexpected nontype template argument kind in template rewrite");
-        return Arg.getAsTemplate();
-      }
 
-      if (TTP->isParameterPack()) {
-        assert(Arg.getKind() == TemplateArgument::Pack &&
-               "Missing argument pack");
 
-        if (getSema().ArgumentPackSubstitutionIndex == -1) {
-          // We have the template argument pack to substitute, but we're not
-          // actually expanding the enclosing pack expansion yet. So, just
-          // keep the entire argument pack.
-          return getSema().Context.getSubstTemplateTemplateParmPack(TTP, Arg);
-        }
 
-        Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
-      }
 
-      TemplateName Template = Arg.getAsTemplate().getNameToSubstitute();
-      assert(!Template.isNull() && "Null template template argument");
-      assert(!Template.getAsQualifiedTemplateName() &&
-             "template decl to substitute is qualified?");
 
-      Template = getSema().Context.getSubstTemplateTemplateParm(TTP, Template);
-      return Template;
-    }
+    return getSema().Context.getSubstTemplateTemplateParm(TransTTP, Template);
   }
 
   if (SubstTemplateTemplateParmPackStorage *SubstPack
       = Name.getAsSubstTemplateTemplateParmPack()) {
     if (getSema().ArgumentPackSubstitutionIndex == -1)
       return Name;
 
     TemplateArgument Arg = SubstPack->getArgumentPack();
TemplateInstantiator::TransformSubstNonTypeTemplateParmExpr(
   //            U=SubstNonTypeTemplateParmExpr(Param=U,
   //                                           Expr=ImpCast(
   //                                               decltype(2),
   //                                               SubstNTTPE(Param=U, Expr='a',
   //                                                          Type=char)),
   //                                           Type=decltype(2)))
   // The call to CheckTemplateArgument here produces the ImpCast.
   TemplateArgument Converted;
-  if (SemaRef.CheckTemplateArgument(E->getParameter(), SubstType,
-                                    SubstReplacement.get(),
-                                    Converted).isInvalid())
+  if (SemaRef
+          .CheckTemplateArgument(
+              E->getParameter(), SubstType, SubstReplacement.get(), Converted,
+              Sema::CTAK_Specified, /*DontCanonicalize=*/false)
+          .isInvalid())
     return true;
   return transformNonTypeTemplateParmRef(E->getParameter(),
                                          E->getExprLoc(), Converted);
 }
 
 ExprResult TemplateInstantiator::RebuildVarDeclRefExpr(VarDecl *PD,
                                                        SourceLocation Loc) {
   DeclarationNameInfo NameInfo(PD->getDeclName(), Loc);
if (NewParm && SemaRef.getLangOpts().OpenCL)
     SemaRef.deduceOpenCLAddressSpace(NewParm);
   return NewParm;
 }
 
 QualType
 TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
                                                 TemplateTypeParmTypeLoc TL) {
   const TemplateTypeParmType *T = TL.getTypePtr();
+  TemplateTypeParmDecl *NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(
+      TransformDecl(TL.getNameLoc(), T->getDecl()));
+
   if (T->getDepth() < TemplateArgs.getNumLevels()) {
     // Replace the template type parameter with its corresponding
     // template argument.
 
     // If the corresponding template argument is NULL or doesn't exist, it's
     // because we are performing instantiation from explicitly-specified
     // template arguments in a function template class, but there were some
     // arguments left unspecified.
     if (!TemplateArgs.hasTemplateArgument(T->getDepth(), T->getIndex())) {
-      TemplateTypeParmTypeLoc NewTL
-        = TLB.push<TemplateTypeParmTypeLoc>(TL.getType());
+      QualType NewT = getSema().Context.getTemplateTypeParmType(
+          T->getDepth(), T->getIndex(), T->isParameterPack(), NewTTPDecl);
+      TemplateTypeParmTypeLoc NewTL = TLB.push<TemplateTypeParmTypeLoc>(NewT);
       NewTL.setNameLoc(TL.getNameLoc());
       return TL.getType();
     }
 
     TemplateArgument Arg = TemplateArgs(T->getDepth(), T->getIndex());
 
     if (TemplateArgs.isRewrite()) {
       // We're rewriting the template parameter as a reference to another
       // template parameter.
       if (Arg.getKind() == TemplateArgument::Pack) {
         assert(Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() &&
                "unexpected pack arguments in template rewrite");
         Arg = Arg.pack_begin()->getPackExpansionPattern();
       }
       assert(Arg.getKind() == TemplateArgument::Type &&
              "unexpected nontype template argument kind in template rewrite");
       QualType NewT = Arg.getAsType();
       assert(isa<TemplateTypeParmType>(NewT) &&
              "type parm not rewritten to type parm");
       auto NewTL = TLB.push<TemplateTypeParmTypeLoc>(NewT);
       NewTL.setNameLoc(TL.getNameLoc());
       return NewT;
     }
 
+    const auto *NewT =
+        cast<TemplateTypeParmType>(getSema().Context.getTemplateTypeParmType(
+            T->getDepth(), T->getIndex(), T->isParameterPack(), NewTTPDecl));
+
     Optional<unsigned> PackIndex;
     if (T->isParameterPack()) {
       assert(Arg.getKind() == TemplateArgument::Pack &&
              "Missing argument pack");
 
       if (getSema().ArgumentPackSubstitutionIndex == -1) {
         // We have the template argument pack, but we're not expanding the
         // enclosing pack expansion yet. Just save the template argument
         // pack for later substitution.
-        QualType Result
-          = getSema().Context.getSubstTemplateTypeParmPackType(T, Arg);
+        QualType Result =
+            getSema().Context.getSubstTemplateTypeParmPackType(NewT, Arg);
         SubstTemplateTypeParmPackTypeLoc NewTL
           = TLB.push<SubstTemplateTypeParmPackTypeLoc>(Result);
         NewTL.setNameLoc(TL.getNameLoc());
         return Result;
       }
 
       Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
       PackIndex = getSema().ArgumentPackSubstitutionIndex;
     }
 
     assert(Arg.getKind() == TemplateArgument::Type &&
            "Template argument kind mismatch");
 
     QualType Replacement = Arg.getAsType();
 
     // TODO: only do this uniquing once, at the start of instantiation.
     QualType Result = getSema().Context.getSubstTemplateTypeParmType(
-        T, Replacement, PackIndex);
+        NewT, Replacement, PackIndex);
     SubstTemplateTypeParmTypeLoc NewTL
       = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
     NewTL.setNameLoc(TL.getNameLoc());
     return Result;
   }
 
   // The template type parameter comes from an inner template (e.g.,
   // the template parameter list of a member template inside the
   // template we are instantiating). Create a new template type
   // parameter with the template "level" reduced by one.
-  TemplateTypeParmDecl *NewTTPDecl = nullptr;
-  if (TemplateTypeParmDecl *OldTTPDecl = T->getDecl())
-    NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(
-                                  TransformDecl(TL.getNameLoc(), OldTTPDecl));
-
   QualType Result = getSema().Context.getTemplateTypeParmType(
       TemplateArgs.getNewDepth(T->getDepth()), T->getIndex(),
       T->isParameterPack(), NewTTPDecl);
   TemplateTypeParmTypeLoc NewTL = TLB.push<TemplateTypeParmTypeLoc>(Result);
   NewTL.setNameLoc(TL.getNameLoc());
   return Result;
 }
 
Sema::InstantiateClass(SourceLocation PointOfInstantiation,
   LocalInstantiationScope Scope(*this, MergeWithParentScope);
 
   // Some class state isn't processed immediately but delayed till class
   // instantiation completes. We may not be ready to handle any delayed state
   // already on the stack as it might correspond to a different class, so save
   // it now and put it back later.
   SavePendingParsedClassStateRAII SavedPendingParsedClassState(*this);
 
+  if (const auto *CTSD =
+          dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {
+    const ClassTemplateDecl *CTD = CTSD->getSpecializedTemplate();
+    if (const ClassTemplateDecl *InstFrom =
+            CTD->getInstantiatedFromMemberTemplate()) {
+      TemplateParameterList *NewTPL = CTD->getTemplateParameters();
+      const TemplateParameterList *OldTPL = InstFrom->getTemplateParameters();
+      assert(NewTPL->size() == OldTPL->size());
+      for (unsigned I = 0, E = NewTPL->size(); I < E; ++I)
+        Scope.InstantiatedLocal(OldTPL->getParam(I), NewTPL->getParam(I));
+    }
+  } else {
+    assert(Instantiation->getKind() == Decl::Kind::CXXRecord);
+  }
+
   // Pull attributes from the pattern onto the instantiation.
   InstantiateAttrs(TemplateArgs, Pattern, Instantiation);
 
   // Start the definition of this instantiation.
   Instantiation->startDefinition();
 
   // The instantiation is visible here, even if it was first declared in an
   // unimported module.

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::getDecltypeForExpr(Expr *E) {
   //     - if e is an unparenthesized id-expression or an unparenthesized class
   //       member access (5.2.5), decltype(e) is the type of the entity named
   //       by e. If there is no such entity, or if e names a set of overloaded
   //       functions, the program is ill-formed;
   //
   // We apply the same rules for Objective-C ivar and property references.
   if (const auto *DRE = dyn_cast<DeclRefExpr>(IDExpr)) {
     const ValueDecl *VD = DRE->getDecl();
-    QualType T = VD->getType();
-    return isa<TemplateParamObjectDecl>(VD) ? T.getUnqualifiedType() : T;
+    QualType VT = VD->getType(), ET = DRE->getType();
+    if (const auto *VTL = VT->getAs<LValueReferenceType>())
+      ET = Context.getLValueReferenceType(ET, VTL->isSpelledAsLValue());
+    if (VT->isRValueReferenceType())
+      ET = Context.getRValueReferenceType(ET);
+    if (!Context.hasSameType(ET, VT)) {
+      ET.dump();
+      VT.dump();
+      assert(false);
+    }
+    return isa<TemplateParamObjectDecl>(VD) ? ET.getUnqualifiedType() : ET;
   }
   if (const auto *ME = dyn_cast<MemberExpr>(IDExpr)) {
     if (const auto *VD = ME->getMemberDecl())
       if (isa<FieldDecl>(VD) || isa<VarDecl>(VD))
         return VD->getType();
   } else if (const auto *IR = dyn_cast<ObjCIvarRefExpr>(IDExpr)) {
     return IR->getDecl()->getType();
   } else if (const auto *PR = dyn_cast<ObjCPropertyRefExpr>(IDExpr)) {

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 (InstName.getAsDependentTemplateName())
       return SemaRef.Context.getDependentTemplateSpecializationType(Keyword,
                                           QualifierLoc.getNestedNameSpecifier(),
                                                                     Name,
                                                                     Args);
 
     // Otherwise, make an elaborated type wrapping a non-dependent
     // specialization.
-    QualType T =
-    getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
-    if (T.isNull()) return QualType();
+    QualType T = getDerived().RebuildTemplateSpecializationType(SS, InstName,
+                                                                NameLoc, Args);
+    if (T.isNull())
+      return QualType();
 
     if (Keyword == ETK_None && QualifierLoc.getNestedNameSpecifier() == nullptr)
       return T;
 
     return SemaRef.Context.getElaboratedType(Keyword,
                                        QualifierLoc.getNestedNameSpecifier(),
                                              T);
   }
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;
+      QualType FieldType = Member->getType();
+      FieldType = getSema().resugar(SS, Member, ExplicitTemplateArgs, FieldType,
+                                    /*Escapes=*/true);
       return getSema().BuildFieldReferenceExpr(
-          Base, isArrow, OpLoc, EmptySS, cast<FieldDecl>(Member),
-          DeclAccessPair::make(FoundDecl, FoundDecl->getAccess()), MemberNameInfo);
+          Base, isArrow, OpLoc, CXXScopeSpec(), cast<FieldDecl>(Member),
+          FieldType, 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) {
typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc>
     ArgIterator;
   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());

 
 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/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/CXX/temp/temp.deduct.guide/p3.cpp

 template<typename T> void D();
 D() -> int; // expected-error {{a type specifier is required}}
 template<template<typename> typename TT> struct E { // expected-note 2{{template}}
   // FIXME: Should only diagnose this once!
   TT(int) -> TT<int>; // expected-error 2{{cannot specify deduction guide for template template parameter 'TT'}} expected-error {{requires an identifier}}
 };
 
 A(int) -> int; // expected-error {{deduced type 'int' of deduction guide is not a specialization of template 'A'}}
-template<typename T> A(T) -> B<T>; // expected-error {{deduced type 'B<T>' (aka 'A<type-parameter-0-0>') of deduction guide is not written as a specialization of template 'A'}}
+template <typename T> A(T)->B<T>;         // expected-error {{deduced type 'B<T>' (aka 'A<T>') of deduction guide is not written as a specialization of template 'A'}}
 template<typename T> A(T*) -> const A<T>; // expected-error {{deduced type 'const A<T>' of deduction guide is not a specialization of template 'A'}}
 
 // A deduction-guide shall be declared in the same scope as the corresponding
 // class template.
 namespace WrongScope {
   namespace {
     template<typename T> struct AnonNS1 {}; // expected-note {{here}}
     AnonNS1(float) -> AnonNS1<float>; // ok

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

 
 template<typename ...T> struct S9 {};
 template<typename T> using U9 = S9<int, char, T>;
 template<typename T> using V9 = U9<U9<T>>;
 int f9(S9<int, char, U9<const double>>);
 int k9 = f9(V9<double>());
 
 // CHECK-ELIDE-NOTREE: no matching function for call to 'f9'
-// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'S9<[2 * ...], S9<[2 * ...], double>>' to 'S9<[2 * ...], S9<[2 * ...], const double>>' for 1st argument
+// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'S9<[2 * ...], U9<double>>' to 'S9<[2 * ...], U9<const double>>' for 1st argument
 // CHECK-NOELIDE-NOTREE: no matching function for call to 'f9'
-// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'S9<int, char, S9<int, char, double>>' to 'S9<int, char, S9<int, char, const double>>' for 1st argument
+// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'S9<int, char, U9<double>>' to 'S9<int, char, U9<const double>>' for 1st argument
 // CHECK-ELIDE-TREE: no matching function for call to 'f9'
 // CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
 // CHECK-ELIDE-TREE:   S9<
-// CHECK-ELIDE-TREE:     [2 * ...], 
-// CHECK-ELIDE-TREE:     S9<
-// CHECK-ELIDE-TREE:       [2 * ...], 
+// CHECK-ELIDE-TREE:     [2 * ...],
+// CHECK-ELIDE-TREE:     U9<
 // CHECK-ELIDE-TREE:       [double != const double]>>
 // CHECK-NOELIDE-TREE: no matching function for call to 'f9'
 // CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
 // CHECK-NOELIDE-TREE:   S9<
-// CHECK-NOELIDE-TREE:     int, 
-// CHECK-NOELIDE-TREE:     char, 
-// CHECK-NOELIDE-TREE:     S9<
-// CHECK-NOELIDE-TREE:       int, 
-// CHECK-NOELIDE-TREE:       char, 
+// CHECK-NOELIDE-TREE:     int,
+// CHECK-NOELIDE-TREE:     char,
+// CHECK-NOELIDE-TREE:     U9<
 // CHECK-NOELIDE-TREE:       [double != const double]>>
 
 template<typename ...A> class class_types {};
 void set10(class_types<int, int>) {}
 void test10() {
   set10(class_types<int>());
   set10(class_types<int, int, int>());
 }

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

+// RUN: %clang_cc1 -std=c++2b -fsyntax-only              -verify=yep %s
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fno-resugar -verify=nop %s
+
+enum class Foo;
+
+struct Bar {};
+
+using Int = int;
+using Float = float;
+using Struct = Bar;
+
+namespace t1 {
+template <class A1> struct A {
+  static constexpr A1 a = {};
+};
+
+Foo x1 = A<Int>::a;
+// yep-error@-1 {{with an lvalue of type 'const Int' (aka 'const int')}}
+// nop-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 = {};
+};
+
+Foo x1 = A<Int, Struct>::a;
+// yep-error@-1 {{with an lvalue of type 'Int Struct::*const'}}
+// nop-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 = {};
+  };
+};
+
+Foo x1 = A<Float>::B<Struct>::a;
+// yep-error@-1 {{with an lvalue of type 'Float Struct::*const'}}
+// nop-error@-2 {{with an lvalue of type 'float Bar::*const'}}
+} // namespace t3
+
+namespace t4 {
+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;
+Foo x1 = a;
+// yep-error@-1 {{with an lvalue of type 't4::M t4::X::*(t4::A<t4::B, int>::*)()'}} // FIXME
+// nop-error@-2 {{with an lvalue of type 'int t4::B::*(t4::A<t4::B, int>::*)()'}}
+
+A<Y, N> b;
+Foo x2 = (b.*a)();
+// yep-error@-1 {{with an rvalue of type 't4::M t4::X::*'}}
+// nop-error@-2 {{with an rvalue of type 'int t4::B::*'}}
+
+using t1 = decltype((b.*a)());
+Foo x3 = t1{};
+// yep-error@-1 {{with an rvalue of type 't4::t1' (aka 't4::M t4::X::*')}}
+// nop-error@-2 {{with an rvalue of type 't4::t1' (aka 'int t4::B::*')}}
+} // namespace t4
+
+namespace t5 {
+template <class A1> struct A { A1 a; };
+auto [a] = A<Int>{};
+
+Foo x1 = a;
+// yep-error@-1 {{with an lvalue of type 'int'}} // FIXME
+// nop-error@-2 {{with an lvalue of type 'int'}}
+} // namespace t5
+
+namespace t6 {
+template <class A1> struct A {
+  template <class B1> static constexpr B1 (*b)(A1) = nullptr;
+};
+
+Foo x1 = A<Float>::b<Int>;
+// yep-error@-1 {{with an lvalue of type 'Int (*const)(Float)' (aka 'int (*const)(float)')}}
+// nop-error@-2 {{with an lvalue of type 'int (*const)(float)'}}
+} // namespace t6
+
+namespace t7 {
+template <class A1> struct A {
+  template <class B1> static constexpr auto b = (B1(*)(A1)){};
+};
+
+Foo x1 = A<Float>::b<Int>;
+// yep-error@-1 {{with an lvalue of type 'int (*const)(float)'}} // FIXME
+// nop-error@-2 {{with an lvalue of type 'int (*const)(float)'}}
+} // namespace t7
+
+namespace t8 {
+template <class A1> A1 a;
+template <class A2> A2 a<A2 *>;
+
+Foo x1 = a<Int>;
+// yep-error@-1 {{with an lvalue of type 'Int' (aka 'int')}}
+// nop-error@-2 {{with an lvalue of type 'int'}}
+
+Foo x2 = a<Float *>;
+// yep-error@-1 {{with an lvalue of type 'float'}} // FIXME
+// nop-error@-2 {{with an lvalue of type 'float'}}
+} // namespace t8
+
+namespace t9 {
+template <class A1> struct A { A1 foo(); };
+
+Foo x1 = A<Int>().foo();
+// yep-error@-1 {{with an rvalue of type 'int'}} // FIXME
+// nop-error@-2 {{with an rvalue of type 'int'}}
+} // namespace t9
+
+namespace t10 {
+template <class A1> struct A {
+  auto foo() { return A1(); };
+};
+
+Foo x1 = A<Int>().foo();
+// yep-error@-1 {{with an rvalue of type 'int'}} // FIXME
+// nop-error@-2 {{with an rvalue of type 'int'}}
+} // namespace t10

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_NOT(typename T1::type2); // FIXME
+TEST(typename T1::type3);
+} // namespace t12
+
+namespace t13 {
+template <template <typename...> class C, typename... Us> struct foo {
+  template <typename... Ts> using bind = C<Ts..., Us...>;
+};
+template <typename A1, typename A2> struct Y {
+  using type1 = A1;
+  using type2 = A2;
+};
+template <typename... Ts> using Z = Y<Ts...>;
+
+using T1 = typename foo<Z, Bar>::template bind<int>;
+TEST_NOT(typename T1::type1);
+TEST(typename T1::type2);
+
+using T2 = typename foo<Z, int>::template bind<Bar>;
+TEST(typename T2::type1);
+TEST_NOT(typename T2::type2);
+} // namespace t13
+
+namespace t14 {
+template <int, class A1, class...> struct A { using B = A1; };
+template <class A2, class A3, class... A4> struct A<0, A2, A3, A4...> {
+  using B = typename A<0, A3, A4...>::B;
+};
+using T1 = typename A<0, long, short, Bar>::B;
+TEST_NOT(T1); // FIXME
+} // 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;
+};
+struct C : A<int> {
+  using A::type1;
+};
+TEST(C::A<Bar>::type1);
+TEST_NOT(C::A<int>::type1);
+TEST(C::A<Int>::type1);
+} // namespace t16

clang/test/SemaCXX/calling-conv-compat.cpp

-// RUN: %clang_cc1 -fsyntax-only -std=c++11 -fms-extensions -verify -triple i686-pc-win32 %s
-// RUN: %clang_cc1 -fsyntax-only -std=c++11 -fms-extensions -verify -triple x86_64-pc-win32 %s
+// RUN: %clang_cc1 -fsyntax-only -std=c++11 -fms-extensions -verify=expected,i686 -triple i686-pc-win32 %s
+// RUN: %clang_cc1 -fsyntax-only -std=c++11 -fms-extensions -verify=expected      -triple x86_64-pc-win32 %s
 
 // FIXME: Extend this portion of the test to cover the 64-bit case.
 #if !_M_X64
 
 // Pointers to free functions
 void            free_func_default();
 void __cdecl    free_func_cdecl();
 void __stdcall  free_func_stdcall();

 fun_fastcall A::*td4 = &A::method_fastcall;
 
 // Round trip the function type through a template, and verify that only cdecl
 // gets adjusted.
 template<typename Fn> struct X { typedef Fn A::*p; };
 
 X<void            ()>::p tmpl1 = &A::method_thiscall;
 X<void __cdecl    ()>::p tmpl2 = &A::method_thiscall;
+// i686-error@-1 {{cannot initialize a variable of type 'X<void () __attribute__((cdecl))>::p' (aka 'void (MemberPointers::A::*)() __attribute__((cdecl))') with an rvalue of type 'void (MemberPointers::A::*)() __attribute__((thiscall))'}}
 X<void __stdcall  ()>::p tmpl3 = &A::method_stdcall;
 X<void __fastcall ()>::p tmpl4 = &A::method_fastcall;
 
 X<fun_default >::p tmpl5 = &A::method_thiscall;
 X<fun_cdecl   >::p tmpl6 = &A::method_thiscall;
 X<fun_stdcall >::p tmpl7 = &A::method_stdcall;
 X<fun_fastcall>::p tmpl8 = &A::method_fastcall;
 
 // Make sure we adjust thiscall to cdecl when extracting the function type from
 // a member pointer.
 template <typename> struct Y;
 
 template <typename Fn, typename C>
 struct Y<Fn C::*> {
   typedef Fn *p;
 };
 
 void __cdecl f_cdecl();
 Y<decltype(&A::method_thiscall)>::p tmpl9 = &f_cdecl;
-
+// i686-error-re@-1 {{cannot initialize a variable of type '{{.*}}' (aka 'void (*)() __attribute__((thiscall))') with an rvalue of type 'void (*)() __attribute__((cdecl))'}}
 
 } // end namespace MemberPointers
 
 // Test that lambdas that capture nothing convert to cdecl function pointers.
 namespace Lambdas {
 void pass_fptr_cdecl   (void (__cdecl    *fp)());
 void pass_fptr_stdcall (void (__stdcall  *fp)());
 void pass_fptr_fastcall(void (__fastcall *fp)());

clang/test/SemaTemplate/pr47676.cpp

// CHECK-NEXT: |         `-ImplicitCastExpr {{.*}}'__vector float' <LValueToRValue>
 
   f<double>(nullptr);
 //      CHECK: | `-FunctionDecl {{.*}} f 'void (double *)'
 
 //      CHECK: |     | `-CStyleCastExpr {{.*}} '__vector int' <VectorSplat>
 // CHECK-NEXT: |     |   `-ImplicitCastExpr {{.*}} 'int' <FloatingToIntegral>
 // CHECK-NEXT: |     |     `-ImplicitCastExpr {{.*}}'double' <LValueToRValue>
 
   //      CHECK: |       `-CStyleCastExpr {{.*}} '__vector int' <VectorSplat>
   // CHECK-NEXT: |         `-ImplicitCastExpr {{.*}} 'int' <FloatingToIntegral>
-// CHECK-NEXT: |           `-ImplicitCastExpr {{.*}}:'double' <LValueToRValue>
+  // CHECK-NEXT: |           `-ImplicitCastExpr {{.*}}'double' <LValueToRValue>
 }

clang/test/SemaTemplate/temp_arg_nontype.cpp

 
 namespace dependent_nested_partial_specialization {
   template<typename> using X = int; // expected-warning {{C++11}}
   template<typename T> using Y = T*; // expected-warning {{C++11}}
   int n;
 
   template<template<typename> class X> struct A {
     template<typename T, X<T> N> struct B; // expected-note 2{{here}}
-    template<typename T> struct B<T, 0> {}; // expected-error {{non-type template argument specializes a template parameter with dependent type 'Y<T>' (aka 'type-parameter-0-0 *')}}
+    template <typename T> struct B<T, 0> {}; // expected-error {{non-type template argument specializes a template parameter with dependent type 'Y<T>' (aka 'T *')}}
   };
   A<X>::B<int, 0> ax;
   A<Y>::B<int, &n> ay; // expected-error {{undefined}} expected-note {{instantiation of}}
 
   template<template<typename> class X> struct C {
     template<typename T, int N, int M> struct D; // expected-note {{here}}
     template<typename T, X<T> N> struct D<T*, N, N + 1> {}; // expected-error {{type of specialized non-type template argument depends on}}
   };

clang/unittests/Tooling/QualTypeNamesTest.cpp

if (ExpectedName != "") {
       std::string ActualName = TypeName::getFullyQualifiedName(
           VD->getType(), *Context, Policy, WithGlobalNsPrefix);
       if (ExpectedName != ActualName) {
         // A custom message makes it much easier to see what declaration
         // failed compared to EXPECT_EQ.
         ADD_FAILURE() << "Typename::getFullyQualifiedName failed for "
                       << VD->getQualifiedNameAsString() << std::endl
                       << "   Actual: " << ActualName << std::endl
-                      << " Exepcted: " << ExpectedName;
+                      << " Expected: " << ExpectedName;
       }
     }
     return true;
   }
 };
 
 // named namespaces inside anonymous namespaces
 
-TEST(QualTypeNameTest, getFullyQualifiedName) {
+TEST(QualTypeNameTest, Simple) {
   TypeNameVisitor Visitor;
   // Simple case to test the test framework itself.
   Visitor.ExpectedQualTypeNames["CheckInt"] = "int";
 
   // Keeping the names of the variables whose types we check unique
   // within the entire test--regardless of their own scope--makes it
   // easier to diagnose test failures.
 
Visitor.runOver(
       "var.non_dependent_type_var = 0;\n"
       "}\n"
       "class EnumScopeClass {\n"
       "public:\n"
       "  enum AnEnum { ZERO, ONE };\n"
       "};\n"
       "EnumScopeClass::AnEnum AnEnumVar;\n",
       TypeNameVisitor::Lang_CXX11);
+}
 
+TEST(QualTypeNameTest, Complex) {
   TypeNameVisitor Complex;
   Complex.ExpectedQualTypeNames["CheckTX"] = "B::TX";
   Complex.runOver(
       "namespace A {"
       "  struct X {};"
       "}"
       "using A::X;"
       "namespace fake_std {"
       "  template<class... Types > class tuple {};"
       "}"
       "namespace B {"
       "  using fake_std::tuple;"
       "  typedef tuple<X> TX;"
       "  TX CheckTX;"
       "  struct A { typedef int X; };"
       "}");
+}
 
+TEST(QualTypeNameTest, DoubleUsing) {
   TypeNameVisitor DoubleUsing;
   DoubleUsing.ExpectedQualTypeNames["direct"] = "a::A<0>";
   DoubleUsing.ExpectedQualTypeNames["indirect"] = "b::B";
   DoubleUsing.ExpectedQualTypeNames["double_indirect"] = "b::B";
   DoubleUsing.runOver(R"cpp(
     namespace a {
       template<int> class A {};
       A<0> direct;
     }
     namespace b {
       using B = ::a::A<0>;
       B indirect;
     }
     namespace b {
       using ::b::B;
       B double_indirect;
     }
   )cpp");
+}
 
+TEST(QualTypeNameTest, GlobalNsPrefix) {
   TypeNameVisitor GlobalNsPrefix;
   GlobalNsPrefix.WithGlobalNsPrefix = true;
   GlobalNsPrefix.ExpectedQualTypeNames["IntVal"] = "int";
   GlobalNsPrefix.ExpectedQualTypeNames["BoolVal"] = "bool";
   GlobalNsPrefix.ExpectedQualTypeNames["XVal"] = "::A::B::X";
   GlobalNsPrefix.ExpectedQualTypeNames["IntAliasVal"] = "::A::B::Alias<int>";
   GlobalNsPrefix.ExpectedQualTypeNames["ZVal"] = "::A::B::Y::Z";
   GlobalNsPrefix.ExpectedQualTypeNames["GlobalZVal"] = "::Z";
GlobalNsPrefix.runOver(
       "  namespace D {\n"
       "    namespace {\n"
       "      class aStruct {};\n"
       "      aStruct CheckK;\n"
       "    }\n"
       "  }\n"
       "}\n"
   );
+}
 
+TEST(QualTypeNameTest, InlineNamespace) {
   TypeNameVisitor InlineNamespace;
   InlineNamespace.ExpectedQualTypeNames["c"] = "B::C";
   InlineNamespace.runOver("inline namespace A {\n"
                           "  namespace B {\n"
                           "    class C {};\n"
                           "  }\n"
                           "}\n"
                           "using namespace A::B;\n"
                           "C c;\n",
                           TypeNameVisitor::Lang_CXX11);
+}
 
+TEST(QualTypeNameTest, AnonStrucs) {
   TypeNameVisitor AnonStrucs;
   AnonStrucs.ExpectedQualTypeNames["a"] = "short";
   AnonStrucs.ExpectedQualTypeNames["un_in_st_1"] =
       "union (unnamed struct at input.cc:1:1)::(unnamed union at "
       "input.cc:2:27)";
   AnonStrucs.ExpectedQualTypeNames["b"] = "short";
   AnonStrucs.ExpectedQualTypeNames["un_in_st_2"] =
       "union (unnamed struct at input.cc:1:1)::(unnamed union at "