SemanticHighlighting.h

Go to the documentation of this file.

//==-- SemanticHighlighting.h - Generating highlights from the AST-- 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
//
//===----------------------------------------------------------------------===//
//
// This file supports semantic highlighting: categorizing tokens in the file so
// that the editor can color/style them differently.
// This is particularly valuable for C++: its complex and context-dependent
// grammar is a challenge for simple syntax-highlighting techniques.
//
// Semantic highlightings are calculated for an AST by visiting every AST node
// and classifying nodes that are interesting to highlight (variables/function
// calls etc.).
//
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_SEMANTICHIGHLIGHTING_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_SEMANTICHIGHLIGHTING_H
 
#include "Protocol.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/raw_ostream.h"
 
namespace clang {
namespace clangd {
class ParsedAST;
 
enum class HighlightingKind {
  Variable = 0,
  LocalVariable,
  Parameter,
  Function,
  Method,
  StaticMethod,
  Field,
  StaticField,
  Class,
  Interface,
  Enum,
  EnumConstant,
  Typedef,
  Type,
  Unknown,
  Namespace,
  TemplateParameter,
  Concept,
  Primitive,
  Macro,
  Modifier,
  Operator,
  Bracket,
  Label,
 
  // This one is different from the other kinds as it's a line style
  // rather than a token style.
  InactiveCode,
 
  LastKind = InactiveCode
};
 
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, HighlightingKind K);
std::optional<HighlightingKind>
highlightingKindFromString(llvm::StringRef Name);
 
enum class HighlightingModifier {
  Declaration,
  Definition,
  Deprecated,
  Deduced,
  Readonly,
  Static,
  Abstract,
  Virtual,
  DependentName,
  DefaultLibrary,
  UsedAsMutableReference,
  UsedAsMutablePointer,
  ConstructorOrDestructor,
  UserDefined,
 
  FunctionScope,
  ClassScope,
  FileScope,
  GlobalScope,
 
  LastModifier = GlobalScope
};
static_assert(static_cast<unsigned>(HighlightingModifier::LastModifier) < 32,
              "Increase width of modifiers bitfield!");
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, HighlightingModifier K);
std::optional<HighlightingModifier>
highlightingModifierFromString(llvm::StringRef Name);
 
// Contains all information needed for the highlighting a token.
struct HighlightingToken {
  HighlightingKind Kind;
  uint32_t Modifiers = 0;
  Range R;
 
  HighlightingToken &addModifier(HighlightingModifier M) {
    Modifiers |= 1 << static_cast<unsigned>(M);
    return *this;
  }
};
 
bool operator==(const HighlightingToken &L, const HighlightingToken &R);
bool operator<(const HighlightingToken &L, const HighlightingToken &R);
 
// Returns all HighlightingTokens from an AST. Only generates highlights for the
// main AST.
std::vector<HighlightingToken>
getSemanticHighlightings(ParsedAST &AST, bool IncludeInactiveRegionTokens);
 
std::vector<SemanticToken> toSemanticTokens(llvm::ArrayRef<HighlightingToken>,
                                            llvm::StringRef Code);
llvm::StringRef toSemanticTokenType(HighlightingKind Kind);
llvm::StringRef toSemanticTokenModifier(HighlightingModifier Modifier);
std::vector<SemanticTokensEdit> diffTokens(llvm::ArrayRef<SemanticToken> Before,
                                           llvm::ArrayRef<SemanticToken> After);
 
// Returns ranges of the file that are inside an inactive preprocessor branch.
// The preprocessor directives at the beginning and end of a branch themselves
// are not included.
std::vector<Range> getInactiveRegions(ParsedAST &AST);
 
} // namespace clangd
} // namespace clang
 
#endif