[clang-repl] Consider the scope spec in template lookups for deduction guides

[v.g.vassilev]

Summary

isDeductionGuideName looks up the underlying template and if the template name is qualified we miss that qualification resulting in an error. This issue resurfaced in clang-repl where we call isDeductionGuideName more often to distinguish between if we had a statement or declaration.

This patch passes the CXXScopeSpec information down to LookupTemplateName to make the lookup more precise.

[v.g.vassilev]

ping.

[v.g.vassilev]

Rebase.

[v.g.vassilev]

clang-format

[v.g.vassilev]

Let's rely on a post-commit review here.

[aaron.ballman]

LGTM :-)

[v.g.vassilev]

Thanks! That was blocking our jupyter integration so I decided to go ahead here since we already missed the clang17 train...

clang/include/clang/Sema/Sema.h

public:
 
   bool resolveAssumedTemplateNameAsType(Scope *S, TemplateName &Name,
                                         SourceLocation NameLoc,
                                         bool Diagnose = true);
 
   /// Determine whether a particular identifier might be the name in a C++1z
   /// deduction-guide declaration.
   bool isDeductionGuideName(Scope *S, const IdentifierInfo &Name,
-                            SourceLocation NameLoc,
+                            SourceLocation NameLoc, CXXScopeSpec &SS,
                             ParsedTemplateTy *Template = nullptr);
 
   bool DiagnoseUnknownTemplateName(const IdentifierInfo &II,
                                    SourceLocation IILoc,
                                    Scope *S,
                                    const CXXScopeSpec *SS,
                                    TemplateTy &SuggestedTemplate,
                                    TemplateNameKind &SuggestedKind);

clang/lib/Parse/ParseDecl.cpp

ParseIdentifier: {
           }
           continue;
         }
         goto DoneWithDeclSpec;
       }
 
       // Likewise, if this is a context where the identifier could be a template
       // name, check whether this is a deduction guide declaration.
+      CXXScopeSpec SS;
       if (getLangOpts().CPlusPlus17 &&
           (DSContext == DeclSpecContext::DSC_class ||
            DSContext == DeclSpecContext::DSC_top_level) &&
           Actions.isDeductionGuideName(getCurScope(), *Tok.getIdentifierInfo(),
-                                       Tok.getLocation()) &&
+                                       Tok.getLocation(), SS) &&
           isConstructorDeclarator(/*Unqualified*/ true,
                                   /*DeductionGuide*/ true))
         goto DoneWithDeclSpec;
 
       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
                                      DiagID, TypeRep, Policy);
       if (isInvalid)
         break;

clang/lib/Parse/ParseExprCXX.cpp

ParseIdentifier:
     if (AllowConstructorName &&
         Actions.isCurrentClassName(*Id, getCurScope(), &SS)) {
       // We have parsed a constructor name.
       ParsedType Ty = Actions.getConstructorName(*Id, IdLoc, getCurScope(), SS,
                                                  EnteringContext);
       if (!Ty)
         return true;
       Result.setConstructorName(Ty, IdLoc, IdLoc);
-    } else if (getLangOpts().CPlusPlus17 &&
-               AllowDeductionGuide && SS.isEmpty() &&
-               Actions.isDeductionGuideName(getCurScope(), *Id, IdLoc,
+    } else if (getLangOpts().CPlusPlus17 && AllowDeductionGuide &&
+               SS.isEmpty() &&
+               Actions.isDeductionGuideName(getCurScope(), *Id, IdLoc, SS,
                                             &TemplateName)) {
       // We have parsed a template-name naming a deduction guide.
       Result.setDeductionGuideName(TemplateName, IdLoc);
     } else {
       // We have parsed an identifier.
       Result.setIdentifier(Id, IdLoc);
     }
 

clang/lib/Parse/ParseTentative.cpp

if (DisambiguatingWithExpression) {
       CXXScopeSpec SS;
       ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
                                      /*ObjectHasErrors=*/false,
                                      /*EnteringContext=*/true);
 
       switch (Tok.getKind()) {
       case tok::identifier: {
         IdentifierInfo *II = Tok.getIdentifierInfo();
-        bool isDeductionGuide =
-            Actions.isDeductionGuideName(getCurScope(), *II, Tok.getLocation(),
-                                         /*Template=*/nullptr);
+        bool isDeductionGuide = Actions.isDeductionGuideName(
+            getCurScope(), *II, Tok.getLocation(), SS, /*Template=*/nullptr);
         if (Actions.isCurrentClassName(*II, getCurScope(), &SS) ||
             isDeductionGuide) {
           if (isConstructorDeclarator(/*Unqualified=*/SS.isEmpty(),
                                       isDeductionGuide,
                                       DeclSpec::FriendSpecified::No))
             return true;
         }
         break;

clang/lib/Sema/SemaTemplate.cpp

if (!D && ResultCount > 1) {
     }
   }
 
   TemplateResult = TemplateTy::make(Template);
   return TemplateKind;
 }
 
 bool Sema::isDeductionGuideName(Scope *S, const IdentifierInfo &Name,
-                                SourceLocation NameLoc,
-                                ParsedTemplateTy *Template) {
-  CXXScopeSpec SS;
+                                SourceLocation NameLoc, CXXScopeSpec &SS,
+                                ParsedTemplateTy *Template /*=nullptr*/) {
   bool MemberOfUnknownSpecialization = false;
 
   // We could use redeclaration lookup here, but we don't need to: the
   // syntactic form of a deduction guide is enough to identify it even
   // if we can't look up the template name at all.
   LookupResult R(*this, DeclarationName(&Name), NameLoc, LookupOrdinaryName);
   if (LookupTemplateName(R, S, SS, /*ObjectType*/ QualType(),
                          /*EnteringContext*/ false,

clang/test/Interpreter/disambiguate-decl-stmt.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -fincremental-extensions -std=c++20 %s
 // RUN: %clang_cc1 -fsyntax-only -DMS -fms-extensions -verify -fincremental-extensions -std=c++20 %s
 
 // expected-no-diagnostics
 
 extern "C" int printf(const char*,...);
 
 // Decls which are hard to disambiguate
 
+// Templates
+namespace ns1 { template<typename T> void tmplt(T &) {}}
+int arg_tmplt = 12; ns1::tmplt(arg_tmplt);
+
 // ParseStatementOrDeclaration returns multiple statements.
 #ifdef MS
 int g_bFlag = 1;
 __if_exists(::g_bFlag) {
   printf("Entering __if_exists\n");
   printf("g_bFlag = %d\n", g_bFlag);
 }
 #endif // MS