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
|
//===--- CollectMacros.h -----------------------------------------*- 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
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_COLLECTMACROS_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_COLLECTMACROS_H
#include "AST.h"
#include "Protocol.h"
#include "SourceCode.h"
#include "index/SymbolID.h"
#include "clang/Basic/IdentifierTable.h"
#include "clang/Lex/PPCallbacks.h"
#include "llvm/ADT/DenseMap.h"
#include <string>
namespace clang {
namespace clangd {
struct MacroOccurrence {
// Instead of storing SourceLocation, we have to store the token range because
// SourceManager from preamble is not available when we build the AST.
Range Rng;
bool IsDefinition;
};
struct MainFileMacros {
llvm::StringSet<> Names;
llvm::DenseMap<SymbolID, std::vector<MacroOccurrence>> MacroRefs;
// Somtimes it is not possible to compute the SymbolID for the Macro, e.g. a
// reference to an undefined macro. Store them separately, e.g. for semantic
// highlighting.
std::vector<MacroOccurrence> UnknownMacros;
// Ranges skipped by the preprocessor due to being inactive.
std::vector<Range> SkippedRanges;
};
/// Collects macro references (e.g. definitions, expansions) in the main file.
/// It is used to:
/// - collect macros in the preamble section of the main file (in Preamble.cpp)
/// - collect macros after the preamble of the main file (in ParsedAST.cpp)
class CollectMainFileMacros : public PPCallbacks {
public:
explicit CollectMainFileMacros(const SourceManager &SM, MainFileMacros &Out)
: SM(SM), Out(Out) {}
void FileChanged(SourceLocation Loc, FileChangeReason,
SrcMgr::CharacteristicKind, FileID) override {
InMainFile = isInsideMainFile(Loc, SM);
}
void MacroDefined(const Token &MacroName, const MacroDirective *MD) override {
add(MacroName, MD->getMacroInfo(), /*IsDefinition=*/true);
}
void MacroExpands(const Token &MacroName, const MacroDefinition &MD,
SourceRange Range, const MacroArgs *Args) override {
add(MacroName, MD.getMacroInfo());
}
void MacroUndefined(const clang::Token &MacroName,
const clang::MacroDefinition &MD,
const clang::MacroDirective *Undef) override {
add(MacroName, MD.getMacroInfo());
}
void Ifdef(SourceLocation Loc, const Token &MacroName,
const MacroDefinition &MD) override {
add(MacroName, MD.getMacroInfo());
}
void Ifndef(SourceLocation Loc, const Token &MacroName,
const MacroDefinition &MD) override {
add(MacroName, MD.getMacroInfo());
}
void Defined(const Token &MacroName, const MacroDefinition &MD,
SourceRange Range) override {
add(MacroName, MD.getMacroInfo());
}
void SourceRangeSkipped(SourceRange R, SourceLocation EndifLoc) override {
if (!InMainFile)
return;
Position Begin = sourceLocToPosition(SM, R.getBegin());
Position End = sourceLocToPosition(SM, R.getEnd());
Out.SkippedRanges.push_back(Range{Begin, End});
}
private:
void add(const Token &MacroNameTok, const MacroInfo *MI,
bool IsDefinition = false);
const SourceManager &SM;
bool InMainFile = true;
MainFileMacros &Out;
};
/// Represents a `#pragma mark` in the main file.
///
/// There can be at most one pragma mark per line.
struct PragmaMark {
Range Rng;
std::string Trivia;
};
/// Collect all pragma marks from the main file.
std::unique_ptr<PPCallbacks>
collectPragmaMarksCallback(const SourceManager &, std::vector<PragmaMark> &Out);
} // namespace clangd
} // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_COLLECTMACROS_H
|
