[Sema] Fix an error with C++17 auto non-type template parameters

[erik.pilkington]

Summary

Clang used to error out on the following test case because we were forming a deduced-to-undeduced AutoType, which CheckNonTypeTemplateParameterType can't handle.

template <auto V> struct G {};

template <class T> struct S {
  template <auto V> void f() {
    G<V> x; // (incorrect) error while checking template parameter types
  }
};

The problem here was that CurrentInstantiationRebuilder TreeTransform'd the auto template parameter type of G, which strips away the type-dependent bit (see TreeTransform::RebuildAutoType) which was previously set by CheckNonTypeTemplateParameterType. This patch recovers this information by substituting in the dependent type again. This is a very similar fix to r290660.

rdar://41852459

Thanks for taking a look!
Erik

[erik.pilkington]

New patch uses a different approach to fix this. I edited the summary/title to explain. Sorry for the flip-flop!

[rsmith]

Can you also add a test where the auto is not top-level (eg, template<auto *P>) and a test using decltype(auto)?

lib/Sema/SemaTemplate.cpp

 /// Check that the type of a non-type template parameter is
 /// well-formed.
 ///
 /// \returns the (possibly-promoted) parameter type if valid;
 /// otherwise, produces a diagnostic and returns a NULL type.
 QualType Sema::CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI,
                                                  SourceLocation Loc) {
   if (TSI->getType()->isUndeducedType()) {
-    // C++1z [temp.dep.expr]p3:
+    // C++17 [temp.dep.expr]p3:
     //   An id-expression is type-dependent if it contains
     //    - an identifier associated by name lookup with a non-type
     //      template-parameter declared with a type that contains a
     //      placeholder type (7.1.7.4),
     TSI = SubstAutoTypeSourceInfo(TSI, Context.DependentTy);
   }
 
   return CheckNonTypeTemplateParameterType(TSI->getType(), Loc);
for (unsigned I = 0, N = Params->size(); I != N; ++I) {
     NonTypeTemplateParmDecl *NTTP = cast<NonTypeTemplateParmDecl>(Param);
     TypeSourceInfo *NewTSI
       = RebuildTypeInCurrentInstantiation(NTTP->getTypeSourceInfo(),
                                           NTTP->getLocation(),
                                           NTTP->getDeclName());
     if (!NewTSI)
       return true;
 
+    if (NewTSI->getType()->isUndeducedType()) {
+      // C++17 [temp.dep.expr]p3:
+      //   An id-expression is type-dependent if it contains
+      //    - an identifier associated by name lookup with a non-type
+      //      template-parameter declared with a type that contains a
+      //      placeholder type (7.1.7.4),
+      NewTSI = SubstAutoTypeSourceInfo(NewTSI, Context.DependentTy);
+    }
+
     if (NewTSI != NTTP->getTypeSourceInfo()) {
       NTTP->setTypeSourceInfo(NewTSI);
       NTTP->setType(NewTSI->getType());
     }
   }
 
   return false;
 }

test/SemaTemplate/temp_arg_nontype_cxx1z.cpp

namespace Nested {
   using Int = A<int>::B<&n>::pointee;
 
   void f(int);
   using Int = A<int>::B<&f>::param;
 
   void g(int, int);
   using Int = A<int>::B<&g>::param2;
 }
+
+namespace rdar41852459 {
+template <auto V> struct G {};
+
+template <class T> struct S {
+  template <auto V> void f() {
+    G<V> x;
+  }
+  template <auto *PV> void f2() {
+    G<PV> x;
+  }
+  template <decltype(auto) V> void f3() {
+    G<V> x;
+  }
+};
+
+template <auto *PV> struct I {};
+
+template <class T> struct K {
+  template <auto *PV> void f() {
+    I<PV> x;
+  }
+  template <auto V> void f2() {
+    I<V> x;
+  }
+  template <decltype(auto) V> void f3() {
+    I<V> x;
+  }
+};
+
+template <decltype(auto)> struct L {};
+template <class T> struct M {
+  template <auto *PV> void f() {
+    L<PV> x;
+  }
+  template <auto V> void f() {
+    L<V> x;
+  }
+  template <decltype(auto) V> void f() {
+    L<V> x;
+  }
+};
+}