[clang] Fix the bogus diagnostic introduced by the newly-added UsingTemplate Kind.

[sammccall]

clang/lib/Sema/SemaDeclCXX.cpp

11014

I'd add here "The template name may not be qualified. [temp.deduct.guide]".

This is pretty important to the logic here and never explicitly written down.

11027

It's not quite clear what you're implying by this:

• we want to allow qualified names, but they're not QualifiedTemplateNames? (this was my first reading)
• we want to disallow qualified names, but don't have to worry about QualifiedTemplateNames.

The latter is correct, because the grammar only allows a simple-template-id (the name must be an identifier, no NNS allowed).

I'm not actually sure we want a comment here about qualified names at all - not including it in the || is correct whether or not it could occur here.

By the way, the following code is correctly rejected by clang, but accepted by GCC and MSVC:

namespace ns {
template <typename> class X {};
template <typename T> X(T) -> ns::X<T>;
}

(We're in the right scope, so this isn't just about secondary diagnostics)

11029

The meaning of this || is not clear.

Maybe bool SimplyWritten = ...?

Maybe also // A Using TemplateName can't actually be valid (either it's qualified, or we're in the wrong scope). But we have diagnosed these problems already.

[hokein]

rebase and address comments.

clang/lib/Sema/SemaDeclCXX.cpp

for (const DeclaratorChunk &Chunk : llvm::reverse(D.type_objects())) {
     }
     if (!Chunk.Fun.hasTrailingReturnType()) {
       Diag(D.getName().getBeginLoc(),
            diag::err_deduction_guide_no_trailing_return_type);
       break;
     }
 
     // Check that the return type is written as a specialization of
     // the template specified as the deduction-guide's name.
     ParsedType TrailingReturnType = Chunk.Fun.getTrailingReturnType();
     TypeSourceInfo *TSI = nullptr;
     QualType RetTy = GetTypeFromParser(TrailingReturnType, &TSI);
     assert(TSI && "deduction guide has valid type but invalid return type?");
     bool AcceptableReturnType = false;
     bool MightInstantiateToSpecialization = false;
     if (auto RetTST =
             TSI->getTypeLoc().getAs<TemplateSpecializationTypeLoc>()) {
       TemplateName SpecifiedName = RetTST.getTypePtr()->getTemplateName();
       bool TemplateMatches =
           Context.hasSameTemplateName(SpecifiedName, GuidedTemplate);
-      // FIXME: We should consider other template kinds (using, qualified),
-      // otherwise we will emit bogus diagnostics.
-      if (SpecifiedName.getKind() == TemplateName::Template && TemplateMatches)
+      auto TKind = SpecifiedName.getKind();
+      // Template names within TemplateSpecializationType are never qualified
+      // template names!
+      if ((TKind == TemplateName::Template ||
+           TKind == TemplateName::UsingTemplate) &&
+          TemplateMatches)
         AcceptableReturnType = true;
       else {
         // This could still instantiate to the right type, unless we know it
         // names the wrong class template.
         auto *TD = SpecifiedName.getAsTemplateDecl();
         MightInstantiateToSpecialization = !(TD && isa<ClassTemplateDecl>(TD) &&
                                              !TemplateMatches);
       }

clang/test/CXX/temp/temp.deduct.guide/p3.cpp

namespace {
     AnonNS2(int) -> AnonNS2<int>; // expected-error {{deduction guide must be declared in the same scope as template 'WrongScope::AnonNS2'}}
   }
   namespace N {
     template<typename T> struct NamedNS1 {}; // expected-note {{here}}
     template<typename T> struct NamedNS2 {}; // expected-note {{here}}
   }
   using N::NamedNS1;
   NamedNS1(int) -> NamedNS1<int>; // expected-error {{deduction guide must be declared in the same scope as template}}
-  // FIXME: remove the following bogus diagnostic
-  // expected-error@-2{{deduction guide is not written as a specialization of template 'NamedNS1'}}
 
   using namespace N;
   NamedNS2(int) -> NamedNS2<int>; // expected-error {{deduction guide must be declared in the same scope as template}}
   struct ClassMemberA {
     template<typename T> struct X {}; // expected-note {{here}}
   };
   struct ClassMemberB : ClassMemberA {
     X(int) -> X<int>; // expected-error {{deduction guide must be declared in the same scope as template 'WrongScope::ClassMemberA::X'}}
   };
   template<typename T> struct Local {};
   void f() {
     Local(int) -> Local<int>; // expected-error {{expected}}
     using WrongScope::Local;
     Local(int) -> Local<int>; // expected-error {{expected}}
   }
 }