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

[sammccall]

clang-tools-extra/clangd/SemanticHighlighting.cpp

966

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

969

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

969

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);
if (!K)
       return true;
     SourceLocation StartLoc = D->getTypeSpecStartLoc();
     // 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;
+
+    if (auto *TSI = D->getTypeSourceInfo()) {
+       auto ATL = TSI->getTypeLoc().getContainedAutoTypeLoc();
+       if (ATL.isConstrained()) {
+         StartLoc = ATL.getConceptNameInfo().getEndLoc().getLocWithOffset(1);
+       }
+    }
+
     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;

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]] 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[[>]];