1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
//==-- 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
|
