blob: 25589bb57474ac2c2242501a6225722851770d78 (
plain) (
blame)
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
/*===-- CIndexDiagnostic.h - Diagnostics C Interface ------------*- 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 *|
|* *|
|*===----------------------------------------------------------------------===*|
|* *|
|* Implements the diagnostic functions of the Clang C interface. *|
|* *|
\*===----------------------------------------------------------------------===*/
#ifndef LLVM_CLANG_TOOLS_LIBCLANG_CINDEXDIAGNOSTIC_H
#define LLVM_CLANG_TOOLS_LIBCLANG_CINDEXDIAGNOSTIC_H
#include "clang-c/Index.h"
#include <memory>
#include <vector>
#include <assert.h>
namespace clang {
class LangOptions;
class StoredDiagnostic;
class CXDiagnosticImpl;
class CXDiagnosticSetImpl {
std::vector<std::unique_ptr<CXDiagnosticImpl>> Diagnostics;
const bool IsExternallyManaged;
public:
CXDiagnosticSetImpl(bool isManaged = false)
: IsExternallyManaged(isManaged) {}
virtual ~CXDiagnosticSetImpl();
size_t getNumDiagnostics() const {
return Diagnostics.size();
}
CXDiagnosticImpl *getDiagnostic(unsigned i) const {
assert(i < getNumDiagnostics());
return Diagnostics[i].get();
}
void appendDiagnostic(std::unique_ptr<CXDiagnosticImpl> D);
bool empty() const {
return Diagnostics.empty();
}
bool isExternallyManaged() const { return IsExternallyManaged; }
};
class CXDiagnosticImpl {
public:
enum Kind { StoredDiagnosticKind, LoadedDiagnosticKind,
CustomNoteDiagnosticKind };
virtual ~CXDiagnosticImpl();
/// Return the severity of the diagnostic.
virtual CXDiagnosticSeverity getSeverity() const = 0;
/// Return the location of the diagnostic.
virtual CXSourceLocation getLocation() const = 0;
/// Return the spelling of the diagnostic.
virtual CXString getSpelling() const = 0;
/// Return the text for the diagnostic option.
virtual CXString getDiagnosticOption(CXString *Disable) const = 0;
/// Return the category of the diagnostic.
virtual unsigned getCategory() const = 0;
/// Return the category string of the diagnostic.
virtual CXString getCategoryText() const = 0;
/// Return the number of source ranges for the diagnostic.
virtual unsigned getNumRanges() const = 0;
/// Return the source ranges for the diagnostic.
virtual CXSourceRange getRange(unsigned Range) const = 0;
/// Return the number of FixIts.
virtual unsigned getNumFixIts() const = 0;
/// Return the FixIt information (source range and inserted text).
virtual CXString getFixIt(unsigned FixIt,
CXSourceRange *ReplacementRange) const = 0;
Kind getKind() const { return K; }
CXDiagnosticSetImpl &getChildDiagnostics() {
return ChildDiags;
}
protected:
CXDiagnosticImpl(Kind k) : K(k) {}
CXDiagnosticSetImpl ChildDiags;
void append(std::unique_ptr<CXDiagnosticImpl> D) {
ChildDiags.appendDiagnostic(std::move(D));
}
private:
Kind K;
};
/// The storage behind a CXDiagnostic
struct CXStoredDiagnostic : public CXDiagnosticImpl {
const StoredDiagnostic &Diag;
const LangOptions &LangOpts;
CXStoredDiagnostic(const StoredDiagnostic &Diag,
const LangOptions &LangOpts)
: CXDiagnosticImpl(StoredDiagnosticKind),
Diag(Diag), LangOpts(LangOpts) { }
~CXStoredDiagnostic() override {}
/// Return the severity of the diagnostic.
CXDiagnosticSeverity getSeverity() const override;
/// Return the location of the diagnostic.
CXSourceLocation getLocation() const override;
/// Return the spelling of the diagnostic.
CXString getSpelling() const override;
/// Return the text for the diagnostic option.
CXString getDiagnosticOption(CXString *Disable) const override;
/// Return the category of the diagnostic.
unsigned getCategory() const override;
/// Return the category string of the diagnostic.
CXString getCategoryText() const override;
/// Return the number of source ranges for the diagnostic.
unsigned getNumRanges() const override;
/// Return the source ranges for the diagnostic.
CXSourceRange getRange(unsigned Range) const override;
/// Return the number of FixIts.
unsigned getNumFixIts() const override;
/// Return the FixIt information (source range and inserted text).
CXString getFixIt(unsigned FixIt,
CXSourceRange *ReplacementRange) const override;
static bool classof(const CXDiagnosticImpl *D) {
return D->getKind() == StoredDiagnosticKind;
}
};
namespace cxdiag {
CXDiagnosticSetImpl *lazyCreateDiags(CXTranslationUnit TU,
bool checkIfChanged = false);
} // end namespace cxdiag
} // end namespace clang
#endif
|
