1 /*===-- CIndexDiagnostics.cpp - Diagnostics C Interface ---------*- C++ -*-===*\
2 |* *|
3 |* The LLVM Compiler Infrastructure *|
4 |* *|
5 |* This file is distributed under the University of Illinois Open Source *|
6 |* License. See LICENSE.TXT for details. *|
7 |* *|
8 |*===----------------------------------------------------------------------===*|
9 |* *|
10 |* Implements the diagnostic functions of the Clang C interface. *|
11 |* *|
12 \*===----------------------------------------------------------------------===*/
13 #include "CIndexDiagnostic.h"
14 #include "CIndexer.h"
15 #include "CXTranslationUnit.h"
16 #include "CXSourceLocation.h"
17 #include "CXString.h"
18
19 #include "clang/Basic/DiagnosticOptions.h"
20 #include "clang/Frontend/ASTUnit.h"
21 #include "clang/Frontend/DiagnosticRenderer.h"
22 #include "llvm/ADT/SmallString.h"
23 #include "llvm/Support/raw_ostream.h"
24
25 using namespace clang;
26 using namespace clang::cxloc;
27 using namespace clang::cxdiag;
28 using namespace llvm;
29
~CXDiagnosticSetImpl()30 CXDiagnosticSetImpl::~CXDiagnosticSetImpl() {}
31
32 void
appendDiagnostic(std::unique_ptr<CXDiagnosticImpl> D)33 CXDiagnosticSetImpl::appendDiagnostic(std::unique_ptr<CXDiagnosticImpl> D) {
34 Diagnostics.push_back(std::move(D));
35 }
36
~CXDiagnosticImpl()37 CXDiagnosticImpl::~CXDiagnosticImpl() {}
38
39 namespace {
40 class CXDiagnosticCustomNoteImpl : public CXDiagnosticImpl {
41 std::string Message;
42 CXSourceLocation Loc;
43 public:
CXDiagnosticCustomNoteImpl(StringRef Msg,CXSourceLocation L)44 CXDiagnosticCustomNoteImpl(StringRef Msg, CXSourceLocation L)
45 : CXDiagnosticImpl(CustomNoteDiagnosticKind),
46 Message(Msg), Loc(L) {}
47
~CXDiagnosticCustomNoteImpl()48 ~CXDiagnosticCustomNoteImpl() override {}
49
getSeverity() const50 CXDiagnosticSeverity getSeverity() const override {
51 return CXDiagnostic_Note;
52 }
53
getLocation() const54 CXSourceLocation getLocation() const override {
55 return Loc;
56 }
57
getSpelling() const58 CXString getSpelling() const override {
59 return cxstring::createRef(Message.c_str());
60 }
61
getDiagnosticOption(CXString * Disable) const62 CXString getDiagnosticOption(CXString *Disable) const override {
63 if (Disable)
64 *Disable = cxstring::createEmpty();
65 return cxstring::createEmpty();
66 }
67
getCategory() const68 unsigned getCategory() const override { return 0; }
getCategoryText() const69 CXString getCategoryText() const override { return cxstring::createEmpty(); }
70
getNumRanges() const71 unsigned getNumRanges() const override { return 0; }
getRange(unsigned Range) const72 CXSourceRange getRange(unsigned Range) const override {
73 return clang_getNullRange();
74 }
getNumFixIts() const75 unsigned getNumFixIts() const override { return 0; }
getFixIt(unsigned FixIt,CXSourceRange * ReplacementRange) const76 CXString getFixIt(unsigned FixIt,
77 CXSourceRange *ReplacementRange) const override {
78 if (ReplacementRange)
79 *ReplacementRange = clang_getNullRange();
80 return cxstring::createEmpty();
81 }
82 };
83
84 class CXDiagnosticRenderer : public DiagnosticNoteRenderer {
85 public:
CXDiagnosticRenderer(const LangOptions & LangOpts,DiagnosticOptions * DiagOpts,CXDiagnosticSetImpl * mainSet)86 CXDiagnosticRenderer(const LangOptions &LangOpts,
87 DiagnosticOptions *DiagOpts,
88 CXDiagnosticSetImpl *mainSet)
89 : DiagnosticNoteRenderer(LangOpts, DiagOpts),
90 CurrentSet(mainSet), MainSet(mainSet) {}
91
~CXDiagnosticRenderer()92 ~CXDiagnosticRenderer() override {}
93
beginDiagnostic(DiagOrStoredDiag D,DiagnosticsEngine::Level Level)94 void beginDiagnostic(DiagOrStoredDiag D,
95 DiagnosticsEngine::Level Level) override {
96
97 const StoredDiagnostic *SD = D.dyn_cast<const StoredDiagnostic*>();
98 if (!SD)
99 return;
100
101 if (Level != DiagnosticsEngine::Note)
102 CurrentSet = MainSet;
103
104 auto Owner = llvm::make_unique<CXStoredDiagnostic>(*SD, LangOpts);
105 CXStoredDiagnostic &CD = *Owner;
106 CurrentSet->appendDiagnostic(std::move(Owner));
107
108 if (Level != DiagnosticsEngine::Note)
109 CurrentSet = &CD.getChildDiagnostics();
110 }
111
emitDiagnosticMessage(FullSourceLoc Loc,PresumedLoc PLoc,DiagnosticsEngine::Level Level,StringRef Message,ArrayRef<CharSourceRange> Ranges,DiagOrStoredDiag D)112 void emitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
113 DiagnosticsEngine::Level Level, StringRef Message,
114 ArrayRef<CharSourceRange> Ranges,
115 DiagOrStoredDiag D) override {
116 if (!D.isNull())
117 return;
118
119 CXSourceLocation L;
120 if (Loc.hasManager())
121 L = translateSourceLocation(Loc.getManager(), LangOpts, Loc);
122 else
123 L = clang_getNullLocation();
124 CurrentSet->appendDiagnostic(
125 llvm::make_unique<CXDiagnosticCustomNoteImpl>(Message, L));
126 }
127
emitDiagnosticLoc(FullSourceLoc Loc,PresumedLoc PLoc,DiagnosticsEngine::Level Level,ArrayRef<CharSourceRange> Ranges)128 void emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
129 DiagnosticsEngine::Level Level,
130 ArrayRef<CharSourceRange> Ranges) override {}
131
emitCodeContext(FullSourceLoc Loc,DiagnosticsEngine::Level Level,SmallVectorImpl<CharSourceRange> & Ranges,ArrayRef<FixItHint> Hints)132 void emitCodeContext(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
133 SmallVectorImpl<CharSourceRange> &Ranges,
134 ArrayRef<FixItHint> Hints) override {}
135
emitNote(FullSourceLoc Loc,StringRef Message)136 void emitNote(FullSourceLoc Loc, StringRef Message) override {
137 CXSourceLocation L;
138 if (Loc.hasManager())
139 L = translateSourceLocation(Loc.getManager(), LangOpts, Loc);
140 else
141 L = clang_getNullLocation();
142 CurrentSet->appendDiagnostic(
143 llvm::make_unique<CXDiagnosticCustomNoteImpl>(Message, L));
144 }
145
146 CXDiagnosticSetImpl *CurrentSet;
147 CXDiagnosticSetImpl *MainSet;
148 };
149 }
150
lazyCreateDiags(CXTranslationUnit TU,bool checkIfChanged)151 CXDiagnosticSetImpl *cxdiag::lazyCreateDiags(CXTranslationUnit TU,
152 bool checkIfChanged) {
153 ASTUnit *AU = cxtu::getASTUnit(TU);
154
155 if (TU->Diagnostics && checkIfChanged) {
156 // In normal use, ASTUnit's diagnostics should not change unless we reparse.
157 // Currently they can only change by using the internal testing flag
158 // '-error-on-deserialized-decl' which will error during deserialization of
159 // a declaration. What will happen is:
160 //
161 // -c-index-test gets a CXTranslationUnit
162 // -checks the diagnostics, the diagnostics set is lazily created,
163 // no errors are reported
164 // -later does an operation, like annotation of tokens, that triggers
165 // -error-on-deserialized-decl, that will emit a diagnostic error,
166 // that ASTUnit will catch and add to its stored diagnostics vector.
167 // -c-index-test wants to check whether an error occurred after performing
168 // the operation but can only query the lazily created set.
169 //
170 // We check here if a new diagnostic was appended since the last time the
171 // diagnostic set was created, in which case we reset it.
172
173 CXDiagnosticSetImpl *
174 Set = static_cast<CXDiagnosticSetImpl*>(TU->Diagnostics);
175 if (AU->stored_diag_size() != Set->getNumDiagnostics()) {
176 // Diagnostics in the ASTUnit were updated, reset the associated
177 // diagnostics.
178 delete Set;
179 TU->Diagnostics = nullptr;
180 }
181 }
182
183 if (!TU->Diagnostics) {
184 CXDiagnosticSetImpl *Set = new CXDiagnosticSetImpl();
185 TU->Diagnostics = Set;
186 IntrusiveRefCntPtr<DiagnosticOptions> DOpts = new DiagnosticOptions;
187 CXDiagnosticRenderer Renderer(AU->getASTContext().getLangOpts(),
188 &*DOpts, Set);
189
190 for (ASTUnit::stored_diag_iterator it = AU->stored_diag_begin(),
191 ei = AU->stored_diag_end(); it != ei; ++it) {
192 Renderer.emitStoredDiagnostic(*it);
193 }
194 }
195 return static_cast<CXDiagnosticSetImpl*>(TU->Diagnostics);
196 }
197
198 //-----------------------------------------------------------------------------
199 // C Interface Routines
200 //-----------------------------------------------------------------------------
clang_getNumDiagnostics(CXTranslationUnit Unit)201 unsigned clang_getNumDiagnostics(CXTranslationUnit Unit) {
202 if (cxtu::isNotUsableTU(Unit)) {
203 LOG_BAD_TU(Unit);
204 return 0;
205 }
206 if (!cxtu::getASTUnit(Unit))
207 return 0;
208 return lazyCreateDiags(Unit, /*checkIfChanged=*/true)->getNumDiagnostics();
209 }
210
clang_getDiagnostic(CXTranslationUnit Unit,unsigned Index)211 CXDiagnostic clang_getDiagnostic(CXTranslationUnit Unit, unsigned Index) {
212 if (cxtu::isNotUsableTU(Unit)) {
213 LOG_BAD_TU(Unit);
214 return nullptr;
215 }
216
217 CXDiagnosticSet D = clang_getDiagnosticSetFromTU(Unit);
218 if (!D)
219 return nullptr;
220
221 CXDiagnosticSetImpl *Diags = static_cast<CXDiagnosticSetImpl*>(D);
222 if (Index >= Diags->getNumDiagnostics())
223 return nullptr;
224
225 return Diags->getDiagnostic(Index);
226 }
227
clang_getDiagnosticSetFromTU(CXTranslationUnit Unit)228 CXDiagnosticSet clang_getDiagnosticSetFromTU(CXTranslationUnit Unit) {
229 if (cxtu::isNotUsableTU(Unit)) {
230 LOG_BAD_TU(Unit);
231 return nullptr;
232 }
233 if (!cxtu::getASTUnit(Unit))
234 return nullptr;
235 return static_cast<CXDiagnostic>(lazyCreateDiags(Unit));
236 }
237
clang_disposeDiagnostic(CXDiagnostic Diagnostic)238 void clang_disposeDiagnostic(CXDiagnostic Diagnostic) {
239 // No-op. Kept as a legacy API. CXDiagnostics are now managed
240 // by the enclosing CXDiagnosticSet.
241 }
242
clang_formatDiagnostic(CXDiagnostic Diagnostic,unsigned Options)243 CXString clang_formatDiagnostic(CXDiagnostic Diagnostic, unsigned Options) {
244 if (!Diagnostic)
245 return cxstring::createEmpty();
246
247 CXDiagnosticSeverity Severity = clang_getDiagnosticSeverity(Diagnostic);
248
249 SmallString<256> Str;
250 llvm::raw_svector_ostream Out(Str);
251
252 if (Options & CXDiagnostic_DisplaySourceLocation) {
253 // Print source location (file:line), along with optional column
254 // and source ranges.
255 CXFile File;
256 unsigned Line, Column;
257 clang_getSpellingLocation(clang_getDiagnosticLocation(Diagnostic),
258 &File, &Line, &Column, nullptr);
259 if (File) {
260 CXString FName = clang_getFileName(File);
261 Out << clang_getCString(FName) << ":" << Line << ":";
262 clang_disposeString(FName);
263 if (Options & CXDiagnostic_DisplayColumn)
264 Out << Column << ":";
265
266 if (Options & CXDiagnostic_DisplaySourceRanges) {
267 unsigned N = clang_getDiagnosticNumRanges(Diagnostic);
268 bool PrintedRange = false;
269 for (unsigned I = 0; I != N; ++I) {
270 CXFile StartFile, EndFile;
271 CXSourceRange Range = clang_getDiagnosticRange(Diagnostic, I);
272
273 unsigned StartLine, StartColumn, EndLine, EndColumn;
274 clang_getSpellingLocation(clang_getRangeStart(Range),
275 &StartFile, &StartLine, &StartColumn,
276 nullptr);
277 clang_getSpellingLocation(clang_getRangeEnd(Range),
278 &EndFile, &EndLine, &EndColumn, nullptr);
279
280 if (StartFile != EndFile || StartFile != File)
281 continue;
282
283 Out << "{" << StartLine << ":" << StartColumn << "-"
284 << EndLine << ":" << EndColumn << "}";
285 PrintedRange = true;
286 }
287 if (PrintedRange)
288 Out << ":";
289 }
290
291 Out << " ";
292 }
293 }
294
295 /* Print warning/error/etc. */
296 switch (Severity) {
297 case CXDiagnostic_Ignored: llvm_unreachable("impossible");
298 case CXDiagnostic_Note: Out << "note: "; break;
299 case CXDiagnostic_Warning: Out << "warning: "; break;
300 case CXDiagnostic_Error: Out << "error: "; break;
301 case CXDiagnostic_Fatal: Out << "fatal error: "; break;
302 }
303
304 CXString Text = clang_getDiagnosticSpelling(Diagnostic);
305 if (clang_getCString(Text))
306 Out << clang_getCString(Text);
307 else
308 Out << "<no diagnostic text>";
309 clang_disposeString(Text);
310
311 if (Options & (CXDiagnostic_DisplayOption | CXDiagnostic_DisplayCategoryId |
312 CXDiagnostic_DisplayCategoryName)) {
313 bool NeedBracket = true;
314 bool NeedComma = false;
315
316 if (Options & CXDiagnostic_DisplayOption) {
317 CXString OptionName = clang_getDiagnosticOption(Diagnostic, nullptr);
318 if (const char *OptionText = clang_getCString(OptionName)) {
319 if (OptionText[0]) {
320 Out << " [" << OptionText;
321 NeedBracket = false;
322 NeedComma = true;
323 }
324 }
325 clang_disposeString(OptionName);
326 }
327
328 if (Options & (CXDiagnostic_DisplayCategoryId |
329 CXDiagnostic_DisplayCategoryName)) {
330 if (unsigned CategoryID = clang_getDiagnosticCategory(Diagnostic)) {
331 if (Options & CXDiagnostic_DisplayCategoryId) {
332 if (NeedBracket)
333 Out << " [";
334 if (NeedComma)
335 Out << ", ";
336 Out << CategoryID;
337 NeedBracket = false;
338 NeedComma = true;
339 }
340
341 if (Options & CXDiagnostic_DisplayCategoryName) {
342 CXString CategoryName = clang_getDiagnosticCategoryText(Diagnostic);
343 if (NeedBracket)
344 Out << " [";
345 if (NeedComma)
346 Out << ", ";
347 Out << clang_getCString(CategoryName);
348 NeedBracket = false;
349 NeedComma = true;
350 clang_disposeString(CategoryName);
351 }
352 }
353 }
354
355 (void) NeedComma; // Silence dead store warning.
356 if (!NeedBracket)
357 Out << "]";
358 }
359
360 return cxstring::createDup(Out.str());
361 }
362
clang_defaultDiagnosticDisplayOptions()363 unsigned clang_defaultDiagnosticDisplayOptions() {
364 return CXDiagnostic_DisplaySourceLocation | CXDiagnostic_DisplayColumn |
365 CXDiagnostic_DisplayOption;
366 }
367
clang_getDiagnosticSeverity(CXDiagnostic Diag)368 enum CXDiagnosticSeverity clang_getDiagnosticSeverity(CXDiagnostic Diag) {
369 if (CXDiagnosticImpl *D = static_cast<CXDiagnosticImpl*>(Diag))
370 return D->getSeverity();
371 return CXDiagnostic_Ignored;
372 }
373
clang_getDiagnosticLocation(CXDiagnostic Diag)374 CXSourceLocation clang_getDiagnosticLocation(CXDiagnostic Diag) {
375 if (CXDiagnosticImpl *D = static_cast<CXDiagnosticImpl*>(Diag))
376 return D->getLocation();
377 return clang_getNullLocation();
378 }
379
clang_getDiagnosticSpelling(CXDiagnostic Diag)380 CXString clang_getDiagnosticSpelling(CXDiagnostic Diag) {
381 if (CXDiagnosticImpl *D = static_cast<CXDiagnosticImpl *>(Diag))
382 return D->getSpelling();
383 return cxstring::createEmpty();
384 }
385
clang_getDiagnosticOption(CXDiagnostic Diag,CXString * Disable)386 CXString clang_getDiagnosticOption(CXDiagnostic Diag, CXString *Disable) {
387 if (Disable)
388 *Disable = cxstring::createEmpty();
389
390 if (CXDiagnosticImpl *D = static_cast<CXDiagnosticImpl *>(Diag))
391 return D->getDiagnosticOption(Disable);
392
393 return cxstring::createEmpty();
394 }
395
clang_getDiagnosticCategory(CXDiagnostic Diag)396 unsigned clang_getDiagnosticCategory(CXDiagnostic Diag) {
397 if (CXDiagnosticImpl *D = static_cast<CXDiagnosticImpl *>(Diag))
398 return D->getCategory();
399 return 0;
400 }
401
clang_getDiagnosticCategoryName(unsigned Category)402 CXString clang_getDiagnosticCategoryName(unsigned Category) {
403 // Kept for backward compatibility.
404 return cxstring::createRef(DiagnosticIDs::getCategoryNameFromID(Category));
405 }
406
clang_getDiagnosticCategoryText(CXDiagnostic Diag)407 CXString clang_getDiagnosticCategoryText(CXDiagnostic Diag) {
408 if (CXDiagnosticImpl *D = static_cast<CXDiagnosticImpl *>(Diag))
409 return D->getCategoryText();
410 return cxstring::createEmpty();
411 }
412
clang_getDiagnosticNumRanges(CXDiagnostic Diag)413 unsigned clang_getDiagnosticNumRanges(CXDiagnostic Diag) {
414 if (CXDiagnosticImpl *D = static_cast<CXDiagnosticImpl *>(Diag))
415 return D->getNumRanges();
416 return 0;
417 }
418
clang_getDiagnosticRange(CXDiagnostic Diag,unsigned Range)419 CXSourceRange clang_getDiagnosticRange(CXDiagnostic Diag, unsigned Range) {
420 CXDiagnosticImpl *D = static_cast<CXDiagnosticImpl *>(Diag);
421 if (!D || Range >= D->getNumRanges())
422 return clang_getNullRange();
423 return D->getRange(Range);
424 }
425
clang_getDiagnosticNumFixIts(CXDiagnostic Diag)426 unsigned clang_getDiagnosticNumFixIts(CXDiagnostic Diag) {
427 if (CXDiagnosticImpl *D = static_cast<CXDiagnosticImpl *>(Diag))
428 return D->getNumFixIts();
429 return 0;
430 }
431
clang_getDiagnosticFixIt(CXDiagnostic Diag,unsigned FixIt,CXSourceRange * ReplacementRange)432 CXString clang_getDiagnosticFixIt(CXDiagnostic Diag, unsigned FixIt,
433 CXSourceRange *ReplacementRange) {
434 CXDiagnosticImpl *D = static_cast<CXDiagnosticImpl *>(Diag);
435 if (!D || FixIt >= D->getNumFixIts()) {
436 if (ReplacementRange)
437 *ReplacementRange = clang_getNullRange();
438 return cxstring::createEmpty();
439 }
440 return D->getFixIt(FixIt, ReplacementRange);
441 }
442
clang_disposeDiagnosticSet(CXDiagnosticSet Diags)443 void clang_disposeDiagnosticSet(CXDiagnosticSet Diags) {
444 if (CXDiagnosticSetImpl *D = static_cast<CXDiagnosticSetImpl *>(Diags)) {
445 if (D->isExternallyManaged())
446 delete D;
447 }
448 }
449
clang_getDiagnosticInSet(CXDiagnosticSet Diags,unsigned Index)450 CXDiagnostic clang_getDiagnosticInSet(CXDiagnosticSet Diags,
451 unsigned Index) {
452 if (CXDiagnosticSetImpl *D = static_cast<CXDiagnosticSetImpl*>(Diags))
453 if (Index < D->getNumDiagnostics())
454 return D->getDiagnostic(Index);
455 return nullptr;
456 }
457
clang_getChildDiagnostics(CXDiagnostic Diag)458 CXDiagnosticSet clang_getChildDiagnostics(CXDiagnostic Diag) {
459 if (CXDiagnosticImpl *D = static_cast<CXDiagnosticImpl *>(Diag)) {
460 CXDiagnosticSetImpl &ChildDiags = D->getChildDiagnostics();
461 return ChildDiags.empty() ? nullptr : (CXDiagnosticSet) &ChildDiags;
462 }
463 return nullptr;
464 }
465
clang_getNumDiagnosticsInSet(CXDiagnosticSet Diags)466 unsigned clang_getNumDiagnosticsInSet(CXDiagnosticSet Diags) {
467 if (CXDiagnosticSetImpl *D = static_cast<CXDiagnosticSetImpl*>(Diags))
468 return D->getNumDiagnostics();
469 return 0;
470 }
471