[clang] fix transformation of template arguments of 'auto' type constraints

[mizvekov]

Summary

See PR48617.

When assigning the new template arguments to the new TypeLoc, we were looping
on the argument count of the original TypeLoc instead of the new one,
which can be different when packs are present.

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

clang/lib/Sema/TreeTransform.h

QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB,
   AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result);
   NewTL.setNameLoc(TL.getNameLoc());
   NewTL.setNestedNameSpecifierLoc(NewNestedNameSpec);
   NewTL.setTemplateKWLoc(TL.getTemplateKWLoc());
   NewTL.setConceptNameLoc(TL.getConceptNameLoc());
   NewTL.setFoundDecl(TL.getFoundDecl());
   NewTL.setLAngleLoc(TL.getLAngleLoc());
   NewTL.setRAngleLoc(TL.getRAngleLoc());
-  for (unsigned I = 0; I < TL.getNumArgs(); ++I)
+  for (unsigned I = 0; I < NewTL.getNumArgs(); ++I)
     NewTL.setArgLocInfo(I, NewTemplateArgs.arguments()[I].getLocInfo());
 
   return Result;
 }
 
 template <typename Derived>
 QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
                                                         TypeLocBuilder &TLB,

clang/test/CXX/dcl/dcl.spec/dcl.type/dcl.spec.auto/p6.cpp

 
 namespace PR48593 {
   template <class T, class U> concept a = true;
   a<B> auto c = 0; // expected-error{{use of undeclared identifier 'B'}}
 
   template<class> concept d = true;
   d<,> auto e = 0; // expected-error{{expected expression}}
 }
+
+namespace PR48617 {
+  template <typename...> concept C = true;
+  template <typename...> class A {};
+
+  template <typename... Ts> C<Ts...> auto e(A<Ts...>) { return 0; }
+
+  // FIXME: The error here does not make sense.
+  template auto e<>(A<>);
+  // expected-error@-1 {{explicit instantiation of 'e' does not refer to a function template}}
+  // expected-note@-5  {{candidate template ignored: failed template argument deduction}}
+
+  // FIXME: Should be able to instantiate this with no errors.
+  template C<int> auto e<int>(A<int>);
+  // expected-error@-1 {{explicit instantiation of 'e' does not refer to a function template}}
+  // expected-note@-10 {{candidate template ignored: could not match 'C<int, Ts...> auto' against 'C<int> auto'}}
+  
+  template C<> auto e<>(A<>);
+
+  template <typename... Ts> A<Ts...> c(Ts...);
+  int f = e(c(1, 2));
+}