[clangd][c++20]Add missing semantic highlighing for concepts.

[sammccall]

clang-tools-extra/clangd/SemanticHighlighting.cpp

970

if we add this logic it definitely needs a comment explaining that we're looking for the auto token (because we're not doing so directly) and why

973

getLocWithOffset(1) is just jumping one byte in the source code
why is this correct?

IIUC the intention here is to jump to the auto token, and the AutoTypeLoc doesn't actually expose this

I'd suggest:

• for now just bailing out - this is not important enough to hack around (and the current hack doesn't seem robust)
• if you have the appetite, adding this location to AutoTypeLoc seems like a good thing

[massberg]

Set correct token for deduced auto types.

[massberg]

Directly get correct source loc in case of deduced auto types.

[massberg]

clang-tools-extra/clangd/SemanticHighlighting.cpp

973

It seems that we can directly get the correct location, see above.
The test had been wrong before as the auto in auto in Fooable auto f = .. should have a class deduced token as it would have without the concept.
This is now fixed.

[sammccall]

Nice! I forgot about the TypeLoc hierarchy, getNameLoc() isn't so obvious...

clang-tools-extra/clangd/SemanticHighlighting.cpp

public:
   }
 
   bool VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc L) {
     H.addAngleBracketTokens(L.getLAngleLoc(), L.getRAngleLoc());
     return true;
   }
 
   bool VisitAutoTypeLoc(AutoTypeLoc L) {
-    if (L.isConstrained())
+    if (L.isConstrained()) {
       H.addAngleBracketTokens(L.getLAngleLoc(), L.getRAngleLoc());
+      H.addToken(L.getConceptNameInfo().getLoc(), HighlightingKind::Concept);
+    }
     return true;
   }
 
   bool VisitFunctionDecl(FunctionDecl *D) {
     if (D->isOverloadedOperator()) {
       const auto AddOpDeclToken = [&](SourceLocation Loc) {
         auto &Token = H.addToken(Loc, HighlightingKind::Operator)
                           .addModifier(HighlightingModifier::Declaration);
bool VisitDeclaratorDecl(DeclaratorDecl *D) {
     }
     auto *AT = D->getType()->getContainedAutoType();
     if (!AT)
       return true;
     auto K =
         kindForType(AT->getDeducedType().getTypePtrOrNull(), H.getResolver());
     if (!K)
       return true;
-    SourceLocation StartLoc = D->getTypeSpecStartLoc();
+    auto *TSI = D->getTypeSourceInfo();
+    if (!TSI)
+      return true;
+    SourceLocation StartLoc =
+        TSI->getTypeLoc().getContainedAutoTypeLoc().getNameLoc();
     // The AutoType may not have a corresponding token, e.g. in the case of
     // init-captures. In this case, StartLoc overlaps with the location
     // of the decl itself, and producing a token for the type here would result
     // in both it and the token for the decl being dropped due to conflict.
     if (StartLoc == D->getLocation())
       return true;
+
     auto &Tok =
         H.addToken(StartLoc, *K).addModifier(HighlightingModifier::Deduced);
     const Type *Deduced = AT->getDeducedType().getTypePtrOrNull();
     if (auto Mod = scopeModifier(Deduced))
       Tok.addModifier(*Mod);
     if (isDefaultLibrary(Deduced))
       Tok.addModifier(HighlightingModifier::DefaultLibrary);
     return true;
   }
 
   // We handle objective-C selectors specially, because one reference can
   // cover several non-contiguous tokens.

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

)cpp",
           requires($TemplateParameter[[T]] $Parameter_def[[F]]) {
             $Parameter[[F]].$Unknown_dependentName[[foo]]();
           };
       template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
           requires $Concept[[Fooable]]$Bracket[[<]]$TemplateParameter[[T]]$Bracket[[>]]
       void $Function_def[[bar]]($TemplateParameter[[T]] $Parameter_def[[F]]) {
         $Parameter[[F]].$Unknown_dependentName[[foo]]();
       }
+
+      struct $Class_def[[F]] {
+        void $Method_def[[foo]]() {};
+      };
+      $Concept[[Fooable]] $Class_deduced[[auto]] $Variable_def[[f]] = $Class[[F]]();
+
+      void $Function_def[[Bar]]($Concept[[Fooable]] $TemplateParameter[[auto]] $Parameter_def[[x]]) {}
+
+      template$Bracket[[<]]$Concept[[Fooable]] auto $TemplateParameter_def_readonly[[x]]$Bracket[[>]] void $Function_def[[Boo]]() {}
     )cpp",
       // Dependent template name
       R"cpp(
       template $Bracket[[<]]template $Bracket[[<]]typename$Bracket[[>]] class$Bracket[[>]] struct $Class_def[[A]] {};
       template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
       using $Typedef_decl[[W]] = $Class[[A]]$Bracket[[<]]
         $TemplateParameter[[T]]::template $Class_dependentName[[Waldo]]
       $Bracket[[>]];