clang-tools-extra/clangd/SemanticHighlighting.cpp - third_party/llvm-project - Git at Google

 //===--- SemanticHighlighting.cpp - ------------------------- ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

 #include "SemanticHighlighting.h"
 #include "Logger.h"
 #include "Protocol.h"
 #include "SourceCode.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecursiveASTVisitor.h"

 namespace clang {
 namespace clangd {
 namespace {

 // Collects all semantic tokens in an ASTContext.
 class HighlightingTokenCollector
     : public RecursiveASTVisitor<HighlightingTokenCollector> {
   std::vector<HighlightingToken> Tokens;
   ASTContext &Ctx;
   const SourceManager &SM;

 public:
   HighlightingTokenCollector(ParsedAST &AST)
       : Ctx(AST.getASTContext()), SM(AST.getSourceManager()) {}

   std::vector<HighlightingToken> collectTokens() {
     Tokens.clear();
     TraverseAST(Ctx);
     // Initializer lists can give duplicates of tokens, therefore all tokens
     // must be deduplicated.
     llvm::sort(Tokens,
                [](const HighlightingToken &L, const HighlightingToken &R) {
                  return std::tie(L.R, L.Kind) < std::tie(R.R, R.Kind);
                });
     auto Last = std::unique(Tokens.begin(), Tokens.end());
     Tokens.erase(Last, Tokens.end());
     return Tokens;
   }

   bool VisitNamespaceAliasDecl(NamespaceAliasDecl *NAD) {
     // The target namespace of an alias can not be found in any other way.
     addToken(NAD->getTargetNameLoc(), HighlightingKind::Namespace);
     return true;
   }

   bool VisitMemberExpr(MemberExpr *ME) {
     const auto *MD = ME->getMemberDecl();
     if (isa<CXXDestructorDecl>(MD))
       // When calling the destructor manually like: AAA::~A(); The ~ is a
       // MemberExpr. Other methods should still be highlighted though.
       return true;
     addToken(ME->getMemberLoc(), MD);
     return true;
   }

   bool VisitNamedDecl(NamedDecl *ND) {
     // UsingDirectiveDecl's namespaces do not show up anywhere else in the
     // Visit/Traverse mehods. But they should also be highlighted as a
     // namespace.
     if (const auto *UD = dyn_cast<UsingDirectiveDecl>(ND)) {
       addToken(UD->getIdentLocation(), HighlightingKind::Namespace);
       return true;
     }

     // Constructors' TypeLoc has a TypePtr that is a FunctionProtoType. It has
     // no tag decl and therefore constructors must be gotten as NamedDecls
     // instead.
     if (ND->getDeclName().getNameKind() ==
         DeclarationName::CXXConstructorName) {
       addToken(ND->getLocation(), ND);
       return true;
     }

     if (ND->getDeclName().getNameKind() != DeclarationName::Identifier)
       return true;

     addToken(ND->getLocation(), ND);
     return true;
   }

   bool VisitDeclRefExpr(DeclRefExpr *Ref) {
     if (Ref->getNameInfo().getName().getNameKind() !=
         DeclarationName::Identifier)
       // Only want to highlight identifiers.
       return true;

     addToken(Ref->getLocation(), Ref->getDecl());
     return true;
   }

   bool VisitTypedefNameDecl(TypedefNameDecl *TD) {
     if(const auto *TSI = TD->getTypeSourceInfo())
       addTypeLoc(TD->getLocation(), TSI->getTypeLoc());
     return true;
   }

   bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc &TL) {
     // TemplateTypeParmTypeLoc does not have a TagDecl in its type ptr.
     addToken(TL.getBeginLoc(), TL.getDecl());
     return true;
   }

   bool VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc &TL) {
     if (const TemplateDecl *TD =
             TL.getTypePtr()->getTemplateName().getAsTemplateDecl())
       addToken(TL.getBeginLoc(), TD);
     return true;
   }

   bool VisitTypeLoc(TypeLoc &TL) {
     // This check is for not getting two entries when there are anonymous
     // structs. It also makes us not highlight certain namespace qualifiers
     // twice. For elaborated types the actual type is highlighted as an inner
     // TypeLoc.
     if (TL.getTypeLocClass() == TypeLoc::TypeLocClass::Elaborated)
       return true;

     addTypeLoc(TL.getBeginLoc(), TL);
     return true;
   }

   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSLoc) {
     if (NestedNameSpecifier *NNS = NNSLoc.getNestedNameSpecifier())
       if (NNS->getKind() == NestedNameSpecifier::Namespace ||
           NNS->getKind() == NestedNameSpecifier::NamespaceAlias)
         addToken(NNSLoc.getLocalBeginLoc(), HighlightingKind::Namespace);

     return RecursiveASTVisitor<
         HighlightingTokenCollector>::TraverseNestedNameSpecifierLoc(NNSLoc);
   }

 private:
   void addTypeLoc(SourceLocation Loc, const TypeLoc &TL) {
     if (const Type *TP = TL.getTypePtr())
       if (const TagDecl *TD = TP->getAsTagDecl())
         addToken(Loc, TD);
   }

   void addToken(SourceLocation Loc, const NamedDecl *D) {
     if (D->getDeclName().isIdentifier() && D->getName().empty())
       // Don't add symbols that don't have any length.
       return;
     // We highlight class decls, constructor decls and destructor decls as
     // `Class` type. The destructor decls are handled in `VisitTypeLoc` (we will
     // visit a TypeLoc where the underlying Type is a CXXRecordDecl).
     if (isa<ClassTemplateDecl>(D)) {
       addToken(Loc, HighlightingKind::Class);
       return;
     }
     if (isa<RecordDecl>(D)) {
       addToken(Loc, HighlightingKind::Class);
       return;
     }
     if (isa<CXXConstructorDecl>(D)) {
       addToken(Loc, HighlightingKind::Class);
       return;
     }
     if (isa<CXXMethodDecl>(D)) {
       addToken(Loc, HighlightingKind::Method);
       return;
     }
     if (isa<FieldDecl>(D)) {
       addToken(Loc, HighlightingKind::Field);
       return;
     }
     if (isa<EnumDecl>(D)) {
       addToken(Loc, HighlightingKind::Enum);
       return;
     }
     if (isa<EnumConstantDecl>(D)) {
       addToken(Loc, HighlightingKind::EnumConstant);
       return;
     }
     if (isa<VarDecl>(D)) {
       addToken(Loc, HighlightingKind::Variable);
       return;
     }
     if (isa<FunctionDecl>(D)) {
       addToken(Loc, HighlightingKind::Function);
       return;
     }
     if (isa<NamespaceDecl>(D)) {
       addToken(Loc, HighlightingKind::Namespace);
       return;
     }
     if (isa<NamespaceAliasDecl>(D)) {
       addToken(Loc, HighlightingKind::Namespace);
       return;
     }
     if (isa<TemplateTemplateParmDecl>(D)) {
       addToken(Loc, HighlightingKind::TemplateParameter);
       return;
     }
     if (isa<TemplateTypeParmDecl>(D)) {
       addToken(Loc, HighlightingKind::TemplateParameter);
       return;
     }
   }

   void addToken(SourceLocation Loc, HighlightingKind Kind) {
     if (Loc.isMacroID())
       // FIXME: skip tokens inside macros for now.
       return;

     auto R = getTokenRange(SM, Ctx.getLangOpts(), Loc);
     if (!R) {
       // R should always have a value, if it doesn't something is very wrong.
       elog("Tried to add semantic token with an invalid range");
       return;
     }

     Tokens.push_back({Kind, R.getValue()});
   }
 };

 // Encode binary data into base64.
 // This was copied from compiler-rt/lib/fuzzer/FuzzerUtil.cpp.
 // FIXME: Factor this out into llvm/Support?
 std::string encodeBase64(const llvm::SmallVectorImpl<char> &Bytes) {
   static const char Table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                               "abcdefghijklmnopqrstuvwxyz"
                               "0123456789+/";
   std::string Res;
   size_t I;
   for (I = 0; I + 2 < Bytes.size(); I += 3) {
     uint32_t X = (Bytes[I] << 16) + (Bytes[I + 1] << 8) + Bytes[I + 2];
     Res += Table[(X >> 18) & 63];
     Res += Table[(X >> 12) & 63];
     Res += Table[(X >> 6) & 63];
     Res += Table[X & 63];
   }
   if (I + 1 == Bytes.size()) {
     uint32_t X = (Bytes[I] << 16);
     Res += Table[(X >> 18) & 63];
     Res += Table[(X >> 12) & 63];
     Res += "==";
   } else if (I + 2 == Bytes.size()) {
     uint32_t X = (Bytes[I] << 16) + (Bytes[I + 1] << 8);
     Res += Table[(X >> 18) & 63];
     Res += Table[(X >> 12) & 63];
     Res += Table[(X >> 6) & 63];
     Res += "=";
   }
   return Res;
 }

 void write32be(uint32_t I, llvm::raw_ostream &OS) {
   std::array<char, 4> Buf;
   llvm::support::endian::write32be(Buf.data(), I);
   OS.write(Buf.data(), Buf.size());
 }

 void write16be(uint16_t I, llvm::raw_ostream &OS) {
   std::array<char, 2> Buf;
   llvm::support::endian::write16be(Buf.data(), I);
   OS.write(Buf.data(), Buf.size());
 }
 } // namespace

 bool operator==(const HighlightingToken &Lhs, const HighlightingToken &Rhs) {
   return Lhs.Kind == Rhs.Kind && Lhs.R == Rhs.R;
 }

 std::vector<HighlightingToken> getSemanticHighlightings(ParsedAST &AST) {
   return HighlightingTokenCollector(AST).collectTokens();
 }

 std::vector<SemanticHighlightingInformation>
 toSemanticHighlightingInformation(llvm::ArrayRef<HighlightingToken> Tokens) {
   if (Tokens.size() == 0)
     return {};

   // FIXME: Tokens might be multiple lines long (block comments) in this case
   // this needs to add multiple lines for those tokens.
   std::map<int, std::vector<HighlightingToken>> TokenLines;
   for (const HighlightingToken &Token : Tokens)
     TokenLines[Token.R.start.line].push_back(Token);

   std::vector<SemanticHighlightingInformation> Lines;
   Lines.reserve(TokenLines.size());
   for (const auto &Line : TokenLines) {
     llvm::SmallVector<char, 128> LineByteTokens;
     llvm::raw_svector_ostream OS(LineByteTokens);
     for (const auto &Token : Line.second) {
       // Writes the token to LineByteTokens in the byte format specified by the
       // LSP proposal. Described below.
       // |<---- 4 bytes ---->|<-- 2 bytes -->|<--- 2 bytes -->|
       // |    character      |  length       |    index       |

       write32be(Token.R.start.character, OS);
       write16be(Token.R.end.character - Token.R.start.character, OS);
       write16be(static_cast<int>(Token.Kind), OS);
     }

     Lines.push_back({Line.first, encodeBase64(LineByteTokens)});
   }

   return Lines;
 }

 llvm::StringRef toTextMateScope(HighlightingKind Kind) {
   // FIXME: Add scopes for C and Objective C.
   switch (Kind) {
   case HighlightingKind::Function:
     return "entity.name.function.cpp";
   case HighlightingKind::Method:
     return "entity.name.function.method.cpp";
   case HighlightingKind::Variable:
     return "variable.other.cpp";
   case HighlightingKind::Field:
     return "variable.other.field.cpp";
   case HighlightingKind::Class:
     return "entity.name.type.class.cpp";
   case HighlightingKind::Enum:
     return "entity.name.type.enum.cpp";
   case HighlightingKind::EnumConstant:
     return "variable.other.enummember.cpp";
   case HighlightingKind::Namespace:
     return "entity.name.namespace.cpp";
   case HighlightingKind::TemplateParameter:
     return "entity.name.type.template.cpp";
   case HighlightingKind::NumKinds:
     llvm_unreachable("must not pass NumKinds to the function");
   }
   llvm_unreachable("unhandled HighlightingKind");
 }

 } // namespace clangd
 } // namespace clang
	//===--- SemanticHighlighting.cpp - ------------------------- ---- C++ --===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#include "SemanticHighlighting.h"
	#include "Logger.h"
	#include "Protocol.h"
	#include "SourceCode.h"
	#include "clang/AST/ASTContext.h"
	#include "clang/AST/RecursiveASTVisitor.h"

	namespace clang {
	namespace clangd {
	namespace {

	// Collects all semantic tokens in an ASTContext.
	class HighlightingTokenCollector
	: public RecursiveASTVisitor<HighlightingTokenCollector> {
	std::vector<HighlightingToken> Tokens;
	ASTContext &Ctx;
	const SourceManager &SM;

	public:
	HighlightingTokenCollector(ParsedAST &AST)
	: Ctx(AST.getASTContext()), SM(AST.getSourceManager()) {}

	std::vector<HighlightingToken> collectTokens() {
	Tokens.clear();
	TraverseAST(Ctx);
	// Initializer lists can give duplicates of tokens, therefore all tokens
	// must be deduplicated.
	llvm::sort(Tokens,
	[](const HighlightingToken &L, const HighlightingToken &R) {
	return std::tie(L.R, L.Kind) < std::tie(R.R, R.Kind);
	});
	auto Last = std::unique(Tokens.begin(), Tokens.end());
	Tokens.erase(Last, Tokens.end());
	return Tokens;
	}

	bool VisitNamespaceAliasDecl(NamespaceAliasDecl *NAD) {
	// The target namespace of an alias can not be found in any other way.
	addToken(NAD->getTargetNameLoc(), HighlightingKind::Namespace);
	return true;
	}

	bool VisitMemberExpr(MemberExpr *ME) {
	const auto *MD = ME->getMemberDecl();
	if (isa<CXXDestructorDecl>(MD))
	// When calling the destructor manually like: AAA::~A(); The ~ is a
	// MemberExpr. Other methods should still be highlighted though.
	return true;
	addToken(ME->getMemberLoc(), MD);
	return true;
	}

	bool VisitNamedDecl(NamedDecl *ND) {
	// UsingDirectiveDecl's namespaces do not show up anywhere else in the
	// Visit/Traverse mehods. But they should also be highlighted as a
	// namespace.
	if (const auto *UD = dyn_cast<UsingDirectiveDecl>(ND)) {
	addToken(UD->getIdentLocation(), HighlightingKind::Namespace);
	return true;
	}

	// Constructors' TypeLoc has a TypePtr that is a FunctionProtoType. It has
	// no tag decl and therefore constructors must be gotten as NamedDecls
	// instead.
	if (ND->getDeclName().getNameKind() ==
	DeclarationName::CXXConstructorName) {
	addToken(ND->getLocation(), ND);
	return true;
	}

	if (ND->getDeclName().getNameKind() != DeclarationName::Identifier)
	return true;

	addToken(ND->getLocation(), ND);
	return true;
	}

	bool VisitDeclRefExpr(DeclRefExpr *Ref) {
	if (Ref->getNameInfo().getName().getNameKind() !=
	DeclarationName::Identifier)
	// Only want to highlight identifiers.
	return true;

	addToken(Ref->getLocation(), Ref->getDecl());
	return true;
	}

	bool VisitTypedefNameDecl(TypedefNameDecl *TD) {
	if(const auto *TSI = TD->getTypeSourceInfo())
	addTypeLoc(TD->getLocation(), TSI->getTypeLoc());
	return true;
	}

	bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc &TL) {
	// TemplateTypeParmTypeLoc does not have a TagDecl in its type ptr.
	addToken(TL.getBeginLoc(), TL.getDecl());
	return true;
	}

	bool VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc &TL) {
	if (const TemplateDecl *TD =
	TL.getTypePtr()->getTemplateName().getAsTemplateDecl())
	addToken(TL.getBeginLoc(), TD);
	return true;
	}

	bool VisitTypeLoc(TypeLoc &TL) {
	// This check is for not getting two entries when there are anonymous
	// structs. It also makes us not highlight certain namespace qualifiers
	// twice. For elaborated types the actual type is highlighted as an inner
	// TypeLoc.
	if (TL.getTypeLocClass() == TypeLoc::TypeLocClass::Elaborated)
	return true;

	addTypeLoc(TL.getBeginLoc(), TL);
	return true;
	}

	bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSLoc) {
	if (NestedNameSpecifier *NNS = NNSLoc.getNestedNameSpecifier())
	if (NNS->getKind() == NestedNameSpecifier::Namespace \|\|
	NNS->getKind() == NestedNameSpecifier::NamespaceAlias)
	addToken(NNSLoc.getLocalBeginLoc(), HighlightingKind::Namespace);

	return RecursiveASTVisitor<
	HighlightingTokenCollector>::TraverseNestedNameSpecifierLoc(NNSLoc);
	}

	private:
	void addTypeLoc(SourceLocation Loc, const TypeLoc &TL) {
	if (const Type *TP = TL.getTypePtr())
	if (const TagDecl *TD = TP->getAsTagDecl())
	addToken(Loc, TD);
	}

	void addToken(SourceLocation Loc, const NamedDecl *D) {
	if (D->getDeclName().isIdentifier() && D->getName().empty())
	// Don't add symbols that don't have any length.
	return;
	// We highlight class decls, constructor decls and destructor decls as
	// `Class` type. The destructor decls are handled in `VisitTypeLoc` (we will
	// visit a TypeLoc where the underlying Type is a CXXRecordDecl).
	if (isa<ClassTemplateDecl>(D)) {
	addToken(Loc, HighlightingKind::Class);
	return;
	}
	if (isa<RecordDecl>(D)) {
	addToken(Loc, HighlightingKind::Class);
	return;
	}
	if (isa<CXXConstructorDecl>(D)) {
	addToken(Loc, HighlightingKind::Class);
	return;
	}
	if (isa<CXXMethodDecl>(D)) {
	addToken(Loc, HighlightingKind::Method);
	return;
	}
	if (isa<FieldDecl>(D)) {
	addToken(Loc, HighlightingKind::Field);
	return;
	}
	if (isa<EnumDecl>(D)) {
	addToken(Loc, HighlightingKind::Enum);
	return;
	}
	if (isa<EnumConstantDecl>(D)) {
	addToken(Loc, HighlightingKind::EnumConstant);
	return;
	}
	if (isa<VarDecl>(D)) {
	addToken(Loc, HighlightingKind::Variable);
	return;
	}
	if (isa<FunctionDecl>(D)) {
	addToken(Loc, HighlightingKind::Function);
	return;
	}
	if (isa<NamespaceDecl>(D)) {
	addToken(Loc, HighlightingKind::Namespace);
	return;
	}
	if (isa<NamespaceAliasDecl>(D)) {
	addToken(Loc, HighlightingKind::Namespace);
	return;
	}
	if (isa<TemplateTemplateParmDecl>(D)) {
	addToken(Loc, HighlightingKind::TemplateParameter);
	return;
	}
	if (isa<TemplateTypeParmDecl>(D)) {
	addToken(Loc, HighlightingKind::TemplateParameter);
	return;
	}
	}

	void addToken(SourceLocation Loc, HighlightingKind Kind) {
	if (Loc.isMacroID())
	// FIXME: skip tokens inside macros for now.
	return;

	auto R = getTokenRange(SM, Ctx.getLangOpts(), Loc);
	if (!R) {
	// R should always have a value, if it doesn't something is very wrong.
	elog("Tried to add semantic token with an invalid range");
	return;
	}

	Tokens.push_back({Kind, R.getValue()});
	}
	};

	// Encode binary data into base64.
	// This was copied from compiler-rt/lib/fuzzer/FuzzerUtil.cpp.
	// FIXME: Factor this out into llvm/Support?
	std::string encodeBase64(const llvm::SmallVectorImpl<char> &Bytes) {
	static const char Table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
	"abcdefghijklmnopqrstuvwxyz"
	"0123456789+/";
	std::string Res;
	size_t I;
	for (I = 0; I + 2 < Bytes.size(); I += 3) {
	uint32_t X = (Bytes[I] << 16) + (Bytes[I + 1] << 8) + Bytes[I + 2];
	Res += Table[(X >> 18) & 63];
	Res += Table[(X >> 12) & 63];
	Res += Table[(X >> 6) & 63];
	Res += Table[X & 63];
	}
	if (I + 1 == Bytes.size()) {
	uint32_t X = (Bytes[I] << 16);
	Res += Table[(X >> 18) & 63];
	Res += Table[(X >> 12) & 63];
	Res += "==";
	} else if (I + 2 == Bytes.size()) {
	uint32_t X = (Bytes[I] << 16) + (Bytes[I + 1] << 8);
	Res += Table[(X >> 18) & 63];
	Res += Table[(X >> 12) & 63];
	Res += Table[(X >> 6) & 63];
	Res += "=";
	}
	return Res;
	}

	void write32be(uint32_t I, llvm::raw_ostream &OS) {
	std::array<char, 4> Buf;
	llvm::support::endian::write32be(Buf.data(), I);
	OS.write(Buf.data(), Buf.size());
	}

	void write16be(uint16_t I, llvm::raw_ostream &OS) {
	std::array<char, 2> Buf;
	llvm::support::endian::write16be(Buf.data(), I);
	OS.write(Buf.data(), Buf.size());
	}
	} // namespace

	bool operator==(const HighlightingToken &Lhs, const HighlightingToken &Rhs) {
	return Lhs.Kind == Rhs.Kind && Lhs.R == Rhs.R;
	}

	std::vector<HighlightingToken> getSemanticHighlightings(ParsedAST &AST) {
	return HighlightingTokenCollector(AST).collectTokens();
	}

	std::vector<SemanticHighlightingInformation>
	toSemanticHighlightingInformation(llvm::ArrayRef<HighlightingToken> Tokens) {
	if (Tokens.size() == 0)
	return {};

	// FIXME: Tokens might be multiple lines long (block comments) in this case
	// this needs to add multiple lines for those tokens.
	std::map<int, std::vector<HighlightingToken>> TokenLines;
	for (const HighlightingToken &Token : Tokens)
	TokenLines[Token.R.start.line].push_back(Token);

	std::vector<SemanticHighlightingInformation> Lines;
	Lines.reserve(TokenLines.size());
	for (const auto &Line : TokenLines) {
	llvm::SmallVector<char, 128> LineByteTokens;
	llvm::raw_svector_ostream OS(LineByteTokens);
	for (const auto &Token : Line.second) {
	// Writes the token to LineByteTokens in the byte format specified by the
	// LSP proposal. Described below.
	// \|<---- 4 bytes ---->\|<-- 2 bytes -->\|<--- 2 bytes -->\|
	// \| character \| length \| index \|

	write32be(Token.R.start.character, OS);
	write16be(Token.R.end.character - Token.R.start.character, OS);
	write16be(static_cast<int>(Token.Kind), OS);
	}

	Lines.push_back({Line.first, encodeBase64(LineByteTokens)});
	}

	return Lines;
	}

	llvm::StringRef toTextMateScope(HighlightingKind Kind) {
	// FIXME: Add scopes for C and Objective C.
	switch (Kind) {
	case HighlightingKind::Function:
	return "entity.name.function.cpp";
	case HighlightingKind::Method:
	return "entity.name.function.method.cpp";
	case HighlightingKind::Variable:
	return "variable.other.cpp";
	case HighlightingKind::Field:
	return "variable.other.field.cpp";
	case HighlightingKind::Class:
	return "entity.name.type.class.cpp";
	case HighlightingKind::Enum:
	return "entity.name.type.enum.cpp";
	case HighlightingKind::EnumConstant:
	return "variable.other.enummember.cpp";
	case HighlightingKind::Namespace:
	return "entity.name.namespace.cpp";
	case HighlightingKind::TemplateParameter:
	return "entity.name.type.template.cpp";
	case HighlightingKind::NumKinds:
	llvm_unreachable("must not pass NumKinds to the function");
	}
	llvm_unreachable("unhandled HighlightingKind");
	}

	} // namespace clangd
	} // namespace clang