1 | //===- Diagnostic.cpp - C Language Family Diagnostic Handling -------------===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | // |
9 | // This file implements the Diagnostic-related interfaces. |
10 | // |
11 | //===----------------------------------------------------------------------===// |
12 | |
13 | #include "clang/Basic/Diagnostic.h" |
14 | #include "clang/Basic/CharInfo.h" |
15 | #include "clang/Basic/DiagnosticError.h" |
16 | #include "clang/Basic/DiagnosticIDs.h" |
17 | #include "clang/Basic/DiagnosticOptions.h" |
18 | #include "clang/Basic/IdentifierTable.h" |
19 | #include "clang/Basic/PartialDiagnostic.h" |
20 | #include "clang/Basic/SourceLocation.h" |
21 | #include "clang/Basic/SourceManager.h" |
22 | #include "clang/Basic/Specifiers.h" |
23 | #include "clang/Basic/TokenKinds.h" |
24 | #include "llvm/ADT/SmallString.h" |
25 | #include "llvm/ADT/SmallVector.h" |
26 | #include "llvm/ADT/StringExtras.h" |
27 | #include "llvm/ADT/StringRef.h" |
28 | #include "llvm/Support/ConvertUTF.h" |
29 | #include "llvm/Support/CrashRecoveryContext.h" |
30 | #include "llvm/Support/Unicode.h" |
31 | #include "llvm/Support/raw_ostream.h" |
32 | #include <algorithm> |
33 | #include <cassert> |
34 | #include <cstddef> |
35 | #include <cstdint> |
36 | #include <cstring> |
37 | #include <limits> |
38 | #include <string> |
39 | #include <utility> |
40 | #include <vector> |
41 | |
42 | using namespace clang; |
43 | |
44 | const StreamingDiagnostic &clang::operator<<(const StreamingDiagnostic &DB, |
45 | DiagNullabilityKind nullability) { |
46 | DB.AddString( |
47 | V: ("'" + |
48 | getNullabilitySpelling(kind: nullability.first, |
49 | /*isContextSensitive=*/nullability.second) + |
50 | "'" ) |
51 | .str()); |
52 | return DB; |
53 | } |
54 | |
55 | const StreamingDiagnostic &clang::operator<<(const StreamingDiagnostic &DB, |
56 | llvm::Error &&E) { |
57 | DB.AddString(V: toString(E: std::move(E))); |
58 | return DB; |
59 | } |
60 | |
61 | static void DummyArgToStringFn(DiagnosticsEngine::ArgumentKind AK, intptr_t QT, |
62 | StringRef Modifier, StringRef Argument, |
63 | ArrayRef<DiagnosticsEngine::ArgumentValue> PrevArgs, |
64 | SmallVectorImpl<char> &Output, |
65 | void *Cookie, |
66 | ArrayRef<intptr_t> QualTypeVals) { |
67 | StringRef Str = "<can't format argument>" ; |
68 | Output.append(in_start: Str.begin(), in_end: Str.end()); |
69 | } |
70 | |
71 | DiagnosticsEngine::DiagnosticsEngine( |
72 | IntrusiveRefCntPtr<DiagnosticIDs> diags, |
73 | IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, DiagnosticConsumer *client, |
74 | bool ShouldOwnClient) |
75 | : Diags(std::move(diags)), DiagOpts(std::move(DiagOpts)) { |
76 | setClient(client, ShouldOwnClient); |
77 | ArgToStringFn = DummyArgToStringFn; |
78 | |
79 | Reset(); |
80 | } |
81 | |
82 | DiagnosticsEngine::~DiagnosticsEngine() { |
83 | // If we own the diagnostic client, destroy it first so that it can access the |
84 | // engine from its destructor. |
85 | setClient(client: nullptr); |
86 | } |
87 | |
88 | void DiagnosticsEngine::dump() const { |
89 | DiagStatesByLoc.dump(SrcMgr&: *SourceMgr); |
90 | } |
91 | |
92 | void DiagnosticsEngine::dump(StringRef DiagName) const { |
93 | DiagStatesByLoc.dump(SrcMgr&: *SourceMgr, DiagName); |
94 | } |
95 | |
96 | void DiagnosticsEngine::setClient(DiagnosticConsumer *client, |
97 | bool ShouldOwnClient) { |
98 | Owner.reset(p: ShouldOwnClient ? client : nullptr); |
99 | Client = client; |
100 | } |
101 | |
102 | void DiagnosticsEngine::pushMappings(SourceLocation Loc) { |
103 | DiagStateOnPushStack.push_back(x: GetCurDiagState()); |
104 | } |
105 | |
106 | bool DiagnosticsEngine::popMappings(SourceLocation Loc) { |
107 | if (DiagStateOnPushStack.empty()) |
108 | return false; |
109 | |
110 | if (DiagStateOnPushStack.back() != GetCurDiagState()) { |
111 | // State changed at some point between push/pop. |
112 | PushDiagStatePoint(State: DiagStateOnPushStack.back(), L: Loc); |
113 | } |
114 | DiagStateOnPushStack.pop_back(); |
115 | return true; |
116 | } |
117 | |
118 | void DiagnosticsEngine::Reset(bool soft /*=false*/) { |
119 | ErrorOccurred = false; |
120 | UncompilableErrorOccurred = false; |
121 | FatalErrorOccurred = false; |
122 | UnrecoverableErrorOccurred = false; |
123 | |
124 | NumWarnings = 0; |
125 | NumErrors = 0; |
126 | TrapNumErrorsOccurred = 0; |
127 | TrapNumUnrecoverableErrorsOccurred = 0; |
128 | |
129 | CurDiagID = std::numeric_limits<unsigned>::max(); |
130 | LastDiagLevel = DiagnosticIDs::Ignored; |
131 | DelayedDiagID = 0; |
132 | |
133 | if (!soft) { |
134 | // Clear state related to #pragma diagnostic. |
135 | DiagStates.clear(); |
136 | DiagStatesByLoc.clear(); |
137 | DiagStateOnPushStack.clear(); |
138 | |
139 | // Create a DiagState and DiagStatePoint representing diagnostic changes |
140 | // through command-line. |
141 | DiagStates.emplace_back(); |
142 | DiagStatesByLoc.appendFirst(State: &DiagStates.back()); |
143 | } |
144 | } |
145 | |
146 | void DiagnosticsEngine::SetDelayedDiagnostic(unsigned DiagID, StringRef Arg1, |
147 | StringRef Arg2, StringRef Arg3) { |
148 | if (DelayedDiagID) |
149 | return; |
150 | |
151 | DelayedDiagID = DiagID; |
152 | DelayedDiagArg1 = Arg1.str(); |
153 | DelayedDiagArg2 = Arg2.str(); |
154 | DelayedDiagArg3 = Arg3.str(); |
155 | } |
156 | |
157 | void DiagnosticsEngine::ReportDelayed() { |
158 | unsigned ID = DelayedDiagID; |
159 | DelayedDiagID = 0; |
160 | Report(DiagID: ID) << DelayedDiagArg1 << DelayedDiagArg2 << DelayedDiagArg3; |
161 | } |
162 | |
163 | DiagnosticMapping & |
164 | DiagnosticsEngine::DiagState::getOrAddMapping(diag::kind Diag) { |
165 | std::pair<iterator, bool> Result = |
166 | DiagMap.insert(KV: std::make_pair(x&: Diag, y: DiagnosticMapping())); |
167 | |
168 | // Initialize the entry if we added it. |
169 | if (Result.second) |
170 | Result.first->second = DiagnosticIDs::getDefaultMapping(DiagID: Diag); |
171 | |
172 | return Result.first->second; |
173 | } |
174 | |
175 | void DiagnosticsEngine::DiagStateMap::appendFirst(DiagState *State) { |
176 | assert(Files.empty() && "not first" ); |
177 | FirstDiagState = CurDiagState = State; |
178 | CurDiagStateLoc = SourceLocation(); |
179 | } |
180 | |
181 | void DiagnosticsEngine::DiagStateMap::append(SourceManager &SrcMgr, |
182 | SourceLocation Loc, |
183 | DiagState *State) { |
184 | CurDiagState = State; |
185 | CurDiagStateLoc = Loc; |
186 | |
187 | std::pair<FileID, unsigned> Decomp = SrcMgr.getDecomposedLoc(Loc); |
188 | unsigned Offset = Decomp.second; |
189 | for (File *F = getFile(SrcMgr, ID: Decomp.first); F; |
190 | Offset = F->ParentOffset, F = F->Parent) { |
191 | F->HasLocalTransitions = true; |
192 | auto &Last = F->StateTransitions.back(); |
193 | assert(Last.Offset <= Offset && "state transitions added out of order" ); |
194 | |
195 | if (Last.Offset == Offset) { |
196 | if (Last.State == State) |
197 | break; |
198 | Last.State = State; |
199 | continue; |
200 | } |
201 | |
202 | F->StateTransitions.push_back(Elt: {State, Offset}); |
203 | } |
204 | } |
205 | |
206 | DiagnosticsEngine::DiagState * |
207 | DiagnosticsEngine::DiagStateMap::lookup(SourceManager &SrcMgr, |
208 | SourceLocation Loc) const { |
209 | // Common case: we have not seen any diagnostic pragmas. |
210 | if (Files.empty()) |
211 | return FirstDiagState; |
212 | |
213 | std::pair<FileID, unsigned> Decomp = SrcMgr.getDecomposedLoc(Loc); |
214 | const File *F = getFile(SrcMgr, ID: Decomp.first); |
215 | return F->lookup(Offset: Decomp.second); |
216 | } |
217 | |
218 | DiagnosticsEngine::DiagState * |
219 | DiagnosticsEngine::DiagStateMap::File::lookup(unsigned Offset) const { |
220 | auto OnePastIt = |
221 | llvm::partition_point(Range: StateTransitions, P: [=](const DiagStatePoint &P) { |
222 | return P.Offset <= Offset; |
223 | }); |
224 | assert(OnePastIt != StateTransitions.begin() && "missing initial state" ); |
225 | return OnePastIt[-1].State; |
226 | } |
227 | |
228 | DiagnosticsEngine::DiagStateMap::File * |
229 | DiagnosticsEngine::DiagStateMap::getFile(SourceManager &SrcMgr, |
230 | FileID ID) const { |
231 | // Get or insert the File for this ID. |
232 | auto Range = Files.equal_range(x: ID); |
233 | if (Range.first != Range.second) |
234 | return &Range.first->second; |
235 | auto &F = Files.insert(position: Range.first, x: std::make_pair(x&: ID, y: File()))->second; |
236 | |
237 | // We created a new File; look up the diagnostic state at the start of it and |
238 | // initialize it. |
239 | if (ID.isValid()) { |
240 | std::pair<FileID, unsigned> Decomp = SrcMgr.getDecomposedIncludedLoc(FID: ID); |
241 | F.Parent = getFile(SrcMgr, ID: Decomp.first); |
242 | F.ParentOffset = Decomp.second; |
243 | F.StateTransitions.push_back(Elt: {F.Parent->lookup(Offset: Decomp.second), 0}); |
244 | } else { |
245 | // This is the (imaginary) root file into which we pretend all top-level |
246 | // files are included; it descends from the initial state. |
247 | // |
248 | // FIXME: This doesn't guarantee that we use the same ordering as |
249 | // isBeforeInTranslationUnit in the cases where someone invented another |
250 | // top-level file and added diagnostic pragmas to it. See the code at the |
251 | // end of isBeforeInTranslationUnit for the quirks it deals with. |
252 | F.StateTransitions.push_back(Elt: {FirstDiagState, 0}); |
253 | } |
254 | return &F; |
255 | } |
256 | |
257 | void DiagnosticsEngine::DiagStateMap::dump(SourceManager &SrcMgr, |
258 | StringRef DiagName) const { |
259 | llvm::errs() << "diagnostic state at " ; |
260 | CurDiagStateLoc.print(OS&: llvm::errs(), SM: SrcMgr); |
261 | llvm::errs() << ": " << CurDiagState << "\n" ; |
262 | |
263 | for (auto &F : Files) { |
264 | FileID ID = F.first; |
265 | File &File = F.second; |
266 | |
267 | bool PrintedOuterHeading = false; |
268 | auto PrintOuterHeading = [&] { |
269 | if (PrintedOuterHeading) return; |
270 | PrintedOuterHeading = true; |
271 | |
272 | llvm::errs() << "File " << &File << " <FileID " << ID.getHashValue() |
273 | << ">: " << SrcMgr.getBufferOrFake(FID: ID).getBufferIdentifier(); |
274 | |
275 | if (F.second.Parent) { |
276 | std::pair<FileID, unsigned> Decomp = |
277 | SrcMgr.getDecomposedIncludedLoc(FID: ID); |
278 | assert(File.ParentOffset == Decomp.second); |
279 | llvm::errs() << " parent " << File.Parent << " <FileID " |
280 | << Decomp.first.getHashValue() << "> " ; |
281 | SrcMgr.getLocForStartOfFile(FID: Decomp.first) |
282 | .getLocWithOffset(Offset: Decomp.second) |
283 | .print(OS&: llvm::errs(), SM: SrcMgr); |
284 | } |
285 | if (File.HasLocalTransitions) |
286 | llvm::errs() << " has_local_transitions" ; |
287 | llvm::errs() << "\n" ; |
288 | }; |
289 | |
290 | if (DiagName.empty()) |
291 | PrintOuterHeading(); |
292 | |
293 | for (DiagStatePoint &Transition : File.StateTransitions) { |
294 | bool PrintedInnerHeading = false; |
295 | auto PrintInnerHeading = [&] { |
296 | if (PrintedInnerHeading) return; |
297 | PrintedInnerHeading = true; |
298 | |
299 | PrintOuterHeading(); |
300 | llvm::errs() << " " ; |
301 | SrcMgr.getLocForStartOfFile(FID: ID) |
302 | .getLocWithOffset(Offset: Transition.Offset) |
303 | .print(OS&: llvm::errs(), SM: SrcMgr); |
304 | llvm::errs() << ": state " << Transition.State << ":\n" ; |
305 | }; |
306 | |
307 | if (DiagName.empty()) |
308 | PrintInnerHeading(); |
309 | |
310 | for (auto &Mapping : *Transition.State) { |
311 | StringRef Option = |
312 | DiagnosticIDs::getWarningOptionForDiag(DiagID: Mapping.first); |
313 | if (!DiagName.empty() && DiagName != Option) |
314 | continue; |
315 | |
316 | PrintInnerHeading(); |
317 | llvm::errs() << " " ; |
318 | if (Option.empty()) |
319 | llvm::errs() << "<unknown " << Mapping.first << ">" ; |
320 | else |
321 | llvm::errs() << Option; |
322 | llvm::errs() << ": " ; |
323 | |
324 | switch (Mapping.second.getSeverity()) { |
325 | case diag::Severity::Ignored: llvm::errs() << "ignored" ; break; |
326 | case diag::Severity::Remark: llvm::errs() << "remark" ; break; |
327 | case diag::Severity::Warning: llvm::errs() << "warning" ; break; |
328 | case diag::Severity::Error: llvm::errs() << "error" ; break; |
329 | case diag::Severity::Fatal: llvm::errs() << "fatal" ; break; |
330 | } |
331 | |
332 | if (!Mapping.second.isUser()) |
333 | llvm::errs() << " default" ; |
334 | if (Mapping.second.isPragma()) |
335 | llvm::errs() << " pragma" ; |
336 | if (Mapping.second.hasNoWarningAsError()) |
337 | llvm::errs() << " no-error" ; |
338 | if (Mapping.second.hasNoErrorAsFatal()) |
339 | llvm::errs() << " no-fatal" ; |
340 | if (Mapping.second.wasUpgradedFromWarning()) |
341 | llvm::errs() << " overruled" ; |
342 | llvm::errs() << "\n" ; |
343 | } |
344 | } |
345 | } |
346 | } |
347 | |
348 | void DiagnosticsEngine::PushDiagStatePoint(DiagState *State, |
349 | SourceLocation Loc) { |
350 | assert(Loc.isValid() && "Adding invalid loc point" ); |
351 | DiagStatesByLoc.append(SrcMgr&: *SourceMgr, Loc, State); |
352 | } |
353 | |
354 | void DiagnosticsEngine::setSeverity(diag::kind Diag, diag::Severity Map, |
355 | SourceLocation L) { |
356 | assert(Diag < diag::DIAG_UPPER_LIMIT && |
357 | "Can only map builtin diagnostics" ); |
358 | assert((Diags->isBuiltinWarningOrExtension(Diag) || |
359 | (Map == diag::Severity::Fatal || Map == diag::Severity::Error)) && |
360 | "Cannot map errors into warnings!" ); |
361 | assert((L.isInvalid() || SourceMgr) && "No SourceMgr for valid location" ); |
362 | |
363 | // Don't allow a mapping to a warning override an error/fatal mapping. |
364 | bool WasUpgradedFromWarning = false; |
365 | if (Map == diag::Severity::Warning) { |
366 | DiagnosticMapping &Info = GetCurDiagState()->getOrAddMapping(Diag); |
367 | if (Info.getSeverity() == diag::Severity::Error || |
368 | Info.getSeverity() == diag::Severity::Fatal) { |
369 | Map = Info.getSeverity(); |
370 | WasUpgradedFromWarning = true; |
371 | } |
372 | } |
373 | DiagnosticMapping Mapping = makeUserMapping(Map, L); |
374 | Mapping.setUpgradedFromWarning(WasUpgradedFromWarning); |
375 | |
376 | // Make sure we propagate the NoWarningAsError flag from an existing |
377 | // mapping (which may be the default mapping). |
378 | DiagnosticMapping &Info = GetCurDiagState()->getOrAddMapping(Diag); |
379 | Mapping.setNoWarningAsError(Info.hasNoWarningAsError() || |
380 | Mapping.hasNoWarningAsError()); |
381 | |
382 | // Common case; setting all the diagnostics of a group in one place. |
383 | if ((L.isInvalid() || L == DiagStatesByLoc.getCurDiagStateLoc()) && |
384 | DiagStatesByLoc.getCurDiagState()) { |
385 | // FIXME: This is theoretically wrong: if the current state is shared with |
386 | // some other location (via push/pop) we will change the state for that |
387 | // other location as well. This cannot currently happen, as we can't update |
388 | // the diagnostic state at the same location at which we pop. |
389 | DiagStatesByLoc.getCurDiagState()->setMapping(Diag, Info: Mapping); |
390 | return; |
391 | } |
392 | |
393 | // A diagnostic pragma occurred, create a new DiagState initialized with |
394 | // the current one and a new DiagStatePoint to record at which location |
395 | // the new state became active. |
396 | DiagStates.push_back(x: *GetCurDiagState()); |
397 | DiagStates.back().setMapping(Diag, Info: Mapping); |
398 | PushDiagStatePoint(State: &DiagStates.back(), Loc: L); |
399 | } |
400 | |
401 | bool DiagnosticsEngine::setSeverityForGroup(diag::Flavor Flavor, |
402 | StringRef Group, diag::Severity Map, |
403 | SourceLocation Loc) { |
404 | // Get the diagnostics in this group. |
405 | SmallVector<diag::kind, 256> GroupDiags; |
406 | if (Diags->getDiagnosticsInGroup(Flavor, Group, Diags&: GroupDiags)) |
407 | return true; |
408 | |
409 | // Set the mapping. |
410 | for (diag::kind Diag : GroupDiags) |
411 | setSeverity(Diag, Map, L: Loc); |
412 | |
413 | return false; |
414 | } |
415 | |
416 | bool DiagnosticsEngine::setSeverityForGroup(diag::Flavor Flavor, |
417 | diag::Group Group, |
418 | diag::Severity Map, |
419 | SourceLocation Loc) { |
420 | return setSeverityForGroup(Flavor, Group: Diags->getWarningOptionForGroup(Group), |
421 | Map, Loc); |
422 | } |
423 | |
424 | bool DiagnosticsEngine::setDiagnosticGroupWarningAsError(StringRef Group, |
425 | bool Enabled) { |
426 | // If we are enabling this feature, just set the diagnostic mappings to map to |
427 | // errors. |
428 | if (Enabled) |
429 | return setSeverityForGroup(Flavor: diag::Flavor::WarningOrError, Group, |
430 | Map: diag::Severity::Error); |
431 | |
432 | // Otherwise, we want to set the diagnostic mapping's "no Werror" bit, and |
433 | // potentially downgrade anything already mapped to be a warning. |
434 | |
435 | // Get the diagnostics in this group. |
436 | SmallVector<diag::kind, 8> GroupDiags; |
437 | if (Diags->getDiagnosticsInGroup(Flavor: diag::Flavor::WarningOrError, Group, |
438 | Diags&: GroupDiags)) |
439 | return true; |
440 | |
441 | // Perform the mapping change. |
442 | for (diag::kind Diag : GroupDiags) { |
443 | DiagnosticMapping &Info = GetCurDiagState()->getOrAddMapping(Diag); |
444 | |
445 | if (Info.getSeverity() == diag::Severity::Error || |
446 | Info.getSeverity() == diag::Severity::Fatal) |
447 | Info.setSeverity(diag::Severity::Warning); |
448 | |
449 | Info.setNoWarningAsError(true); |
450 | } |
451 | |
452 | return false; |
453 | } |
454 | |
455 | bool DiagnosticsEngine::setDiagnosticGroupErrorAsFatal(StringRef Group, |
456 | bool Enabled) { |
457 | // If we are enabling this feature, just set the diagnostic mappings to map to |
458 | // fatal errors. |
459 | if (Enabled) |
460 | return setSeverityForGroup(Flavor: diag::Flavor::WarningOrError, Group, |
461 | Map: diag::Severity::Fatal); |
462 | |
463 | // Otherwise, we want to set the diagnostic mapping's "no Wfatal-errors" bit, |
464 | // and potentially downgrade anything already mapped to be a fatal error. |
465 | |
466 | // Get the diagnostics in this group. |
467 | SmallVector<diag::kind, 8> GroupDiags; |
468 | if (Diags->getDiagnosticsInGroup(Flavor: diag::Flavor::WarningOrError, Group, |
469 | Diags&: GroupDiags)) |
470 | return true; |
471 | |
472 | // Perform the mapping change. |
473 | for (diag::kind Diag : GroupDiags) { |
474 | DiagnosticMapping &Info = GetCurDiagState()->getOrAddMapping(Diag); |
475 | |
476 | if (Info.getSeverity() == diag::Severity::Fatal) |
477 | Info.setSeverity(diag::Severity::Error); |
478 | |
479 | Info.setNoErrorAsFatal(true); |
480 | } |
481 | |
482 | return false; |
483 | } |
484 | |
485 | void DiagnosticsEngine::setSeverityForAll(diag::Flavor Flavor, |
486 | diag::Severity Map, |
487 | SourceLocation Loc) { |
488 | // Get all the diagnostics. |
489 | std::vector<diag::kind> AllDiags; |
490 | DiagnosticIDs::getAllDiagnostics(Flavor, AllDiags); |
491 | |
492 | // Set the mapping. |
493 | for (diag::kind Diag : AllDiags) |
494 | if (Diags->isBuiltinWarningOrExtension(DiagID: Diag)) |
495 | setSeverity(Diag, Map, L: Loc); |
496 | } |
497 | |
498 | void DiagnosticsEngine::Report(const StoredDiagnostic &storedDiag) { |
499 | assert(CurDiagID == std::numeric_limits<unsigned>::max() && |
500 | "Multiple diagnostics in flight at once!" ); |
501 | |
502 | CurDiagLoc = storedDiag.getLocation(); |
503 | CurDiagID = storedDiag.getID(); |
504 | DiagStorage.NumDiagArgs = 0; |
505 | |
506 | DiagStorage.DiagRanges.clear(); |
507 | DiagStorage.DiagRanges.append(in_start: storedDiag.range_begin(), |
508 | in_end: storedDiag.range_end()); |
509 | |
510 | DiagStorage.FixItHints.clear(); |
511 | DiagStorage.FixItHints.append(in_start: storedDiag.fixit_begin(), |
512 | in_end: storedDiag.fixit_end()); |
513 | |
514 | assert(Client && "DiagnosticConsumer not set!" ); |
515 | Level DiagLevel = storedDiag.getLevel(); |
516 | Diagnostic Info(this, storedDiag.getMessage()); |
517 | Client->HandleDiagnostic(DiagLevel, Info); |
518 | if (Client->IncludeInDiagnosticCounts()) { |
519 | if (DiagLevel == DiagnosticsEngine::Warning) |
520 | ++NumWarnings; |
521 | } |
522 | |
523 | CurDiagID = std::numeric_limits<unsigned>::max(); |
524 | } |
525 | |
526 | bool DiagnosticsEngine::EmitCurrentDiagnostic(bool Force) { |
527 | assert(getClient() && "DiagnosticClient not set!" ); |
528 | |
529 | bool Emitted; |
530 | if (Force) { |
531 | Diagnostic Info(this); |
532 | |
533 | // Figure out the diagnostic level of this message. |
534 | DiagnosticIDs::Level DiagLevel |
535 | = Diags->getDiagnosticLevel(DiagID: Info.getID(), Loc: Info.getLocation(), Diag: *this); |
536 | |
537 | Emitted = (DiagLevel != DiagnosticIDs::Ignored); |
538 | if (Emitted) { |
539 | // Emit the diagnostic regardless of suppression level. |
540 | Diags->EmitDiag(Diag&: *this, DiagLevel); |
541 | } |
542 | } else { |
543 | // Process the diagnostic, sending the accumulated information to the |
544 | // DiagnosticConsumer. |
545 | Emitted = ProcessDiag(); |
546 | } |
547 | |
548 | // Clear out the current diagnostic object. |
549 | Clear(); |
550 | |
551 | // If there was a delayed diagnostic, emit it now. |
552 | if (!Force && DelayedDiagID) |
553 | ReportDelayed(); |
554 | |
555 | return Emitted; |
556 | } |
557 | |
558 | DiagnosticConsumer::~DiagnosticConsumer() = default; |
559 | |
560 | void DiagnosticConsumer::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, |
561 | const Diagnostic &Info) { |
562 | if (!IncludeInDiagnosticCounts()) |
563 | return; |
564 | |
565 | if (DiagLevel == DiagnosticsEngine::Warning) |
566 | ++NumWarnings; |
567 | else if (DiagLevel >= DiagnosticsEngine::Error) |
568 | ++NumErrors; |
569 | } |
570 | |
571 | /// ModifierIs - Return true if the specified modifier matches specified string. |
572 | template <std::size_t StrLen> |
573 | static bool ModifierIs(const char *Modifier, unsigned ModifierLen, |
574 | const char (&Str)[StrLen]) { |
575 | return StrLen-1 == ModifierLen && memcmp(Modifier, Str, StrLen-1) == 0; |
576 | } |
577 | |
578 | /// ScanForward - Scans forward, looking for the given character, skipping |
579 | /// nested clauses and escaped characters. |
580 | static const char *ScanFormat(const char *I, const char *E, char Target) { |
581 | unsigned Depth = 0; |
582 | |
583 | for ( ; I != E; ++I) { |
584 | if (Depth == 0 && *I == Target) return I; |
585 | if (Depth != 0 && *I == '}') Depth--; |
586 | |
587 | if (*I == '%') { |
588 | I++; |
589 | if (I == E) break; |
590 | |
591 | // Escaped characters get implicitly skipped here. |
592 | |
593 | // Format specifier. |
594 | if (!isDigit(c: *I) && !isPunctuation(c: *I)) { |
595 | for (I++; I != E && !isDigit(c: *I) && *I != '{'; I++) ; |
596 | if (I == E) break; |
597 | if (*I == '{') |
598 | Depth++; |
599 | } |
600 | } |
601 | } |
602 | return E; |
603 | } |
604 | |
605 | /// HandleSelectModifier - Handle the integer 'select' modifier. This is used |
606 | /// like this: %select{foo|bar|baz}2. This means that the integer argument |
607 | /// "%2" has a value from 0-2. If the value is 0, the diagnostic prints 'foo'. |
608 | /// If the value is 1, it prints 'bar'. If it has the value 2, it prints 'baz'. |
609 | /// This is very useful for certain classes of variant diagnostics. |
610 | static void HandleSelectModifier(const Diagnostic &DInfo, unsigned ValNo, |
611 | const char *Argument, unsigned ArgumentLen, |
612 | SmallVectorImpl<char> &OutStr) { |
613 | const char *ArgumentEnd = Argument+ArgumentLen; |
614 | |
615 | // Skip over 'ValNo' |'s. |
616 | while (ValNo) { |
617 | const char *NextVal = ScanFormat(I: Argument, E: ArgumentEnd, Target: '|'); |
618 | assert(NextVal != ArgumentEnd && "Value for integer select modifier was" |
619 | " larger than the number of options in the diagnostic string!" ); |
620 | Argument = NextVal+1; // Skip this string. |
621 | --ValNo; |
622 | } |
623 | |
624 | // Get the end of the value. This is either the } or the |. |
625 | const char *EndPtr = ScanFormat(I: Argument, E: ArgumentEnd, Target: '|'); |
626 | |
627 | // Recursively format the result of the select clause into the output string. |
628 | DInfo.FormatDiagnostic(DiagStr: Argument, DiagEnd: EndPtr, OutStr); |
629 | } |
630 | |
631 | /// HandleIntegerSModifier - Handle the integer 's' modifier. This adds the |
632 | /// letter 's' to the string if the value is not 1. This is used in cases like |
633 | /// this: "you idiot, you have %4 parameter%s4!". |
634 | static void HandleIntegerSModifier(unsigned ValNo, |
635 | SmallVectorImpl<char> &OutStr) { |
636 | if (ValNo != 1) |
637 | OutStr.push_back(Elt: 's'); |
638 | } |
639 | |
640 | /// HandleOrdinalModifier - Handle the integer 'ord' modifier. This |
641 | /// prints the ordinal form of the given integer, with 1 corresponding |
642 | /// to the first ordinal. Currently this is hard-coded to use the |
643 | /// English form. |
644 | static void HandleOrdinalModifier(unsigned ValNo, |
645 | SmallVectorImpl<char> &OutStr) { |
646 | assert(ValNo != 0 && "ValNo must be strictly positive!" ); |
647 | |
648 | llvm::raw_svector_ostream Out(OutStr); |
649 | |
650 | // We could use text forms for the first N ordinals, but the numeric |
651 | // forms are actually nicer in diagnostics because they stand out. |
652 | Out << ValNo << llvm::getOrdinalSuffix(Val: ValNo); |
653 | } |
654 | |
655 | /// PluralNumber - Parse an unsigned integer and advance Start. |
656 | static unsigned PluralNumber(const char *&Start, const char *End) { |
657 | // Programming 101: Parse a decimal number :-) |
658 | unsigned Val = 0; |
659 | while (Start != End && *Start >= '0' && *Start <= '9') { |
660 | Val *= 10; |
661 | Val += *Start - '0'; |
662 | ++Start; |
663 | } |
664 | return Val; |
665 | } |
666 | |
667 | /// TestPluralRange - Test if Val is in the parsed range. Modifies Start. |
668 | static bool TestPluralRange(unsigned Val, const char *&Start, const char *End) { |
669 | if (*Start != '[') { |
670 | unsigned Ref = PluralNumber(Start, End); |
671 | return Ref == Val; |
672 | } |
673 | |
674 | ++Start; |
675 | unsigned Low = PluralNumber(Start, End); |
676 | assert(*Start == ',' && "Bad plural expression syntax: expected ," ); |
677 | ++Start; |
678 | unsigned High = PluralNumber(Start, End); |
679 | assert(*Start == ']' && "Bad plural expression syntax: expected )" ); |
680 | ++Start; |
681 | return Low <= Val && Val <= High; |
682 | } |
683 | |
684 | /// EvalPluralExpr - Actual expression evaluator for HandlePluralModifier. |
685 | static bool EvalPluralExpr(unsigned ValNo, const char *Start, const char *End) { |
686 | // Empty condition? |
687 | if (*Start == ':') |
688 | return true; |
689 | |
690 | while (true) { |
691 | char C = *Start; |
692 | if (C == '%') { |
693 | // Modulo expression |
694 | ++Start; |
695 | unsigned Arg = PluralNumber(Start, End); |
696 | assert(*Start == '=' && "Bad plural expression syntax: expected =" ); |
697 | ++Start; |
698 | unsigned ValMod = ValNo % Arg; |
699 | if (TestPluralRange(Val: ValMod, Start, End)) |
700 | return true; |
701 | } else { |
702 | assert((C == '[' || (C >= '0' && C <= '9')) && |
703 | "Bad plural expression syntax: unexpected character" ); |
704 | // Range expression |
705 | if (TestPluralRange(Val: ValNo, Start, End)) |
706 | return true; |
707 | } |
708 | |
709 | // Scan for next or-expr part. |
710 | Start = std::find(first: Start, last: End, val: ','); |
711 | if (Start == End) |
712 | break; |
713 | ++Start; |
714 | } |
715 | return false; |
716 | } |
717 | |
718 | /// HandlePluralModifier - Handle the integer 'plural' modifier. This is used |
719 | /// for complex plural forms, or in languages where all plurals are complex. |
720 | /// The syntax is: %plural{cond1:form1|cond2:form2|:form3}, where condn are |
721 | /// conditions that are tested in order, the form corresponding to the first |
722 | /// that applies being emitted. The empty condition is always true, making the |
723 | /// last form a default case. |
724 | /// Conditions are simple boolean expressions, where n is the number argument. |
725 | /// Here are the rules. |
726 | /// condition := expression | empty |
727 | /// empty := -> always true |
728 | /// expression := numeric [',' expression] -> logical or |
729 | /// numeric := range -> true if n in range |
730 | /// | '%' number '=' range -> true if n % number in range |
731 | /// range := number |
732 | /// | '[' number ',' number ']' -> ranges are inclusive both ends |
733 | /// |
734 | /// Here are some examples from the GNU gettext manual written in this form: |
735 | /// English: |
736 | /// {1:form0|:form1} |
737 | /// Latvian: |
738 | /// {0:form2|%100=11,%10=0,%10=[2,9]:form1|:form0} |
739 | /// Gaeilge: |
740 | /// {1:form0|2:form1|:form2} |
741 | /// Romanian: |
742 | /// {1:form0|0,%100=[1,19]:form1|:form2} |
743 | /// Lithuanian: |
744 | /// {%10=0,%100=[10,19]:form2|%10=1:form0|:form1} |
745 | /// Russian (requires repeated form): |
746 | /// {%100=[11,14]:form2|%10=1:form0|%10=[2,4]:form1|:form2} |
747 | /// Slovak |
748 | /// {1:form0|[2,4]:form1|:form2} |
749 | /// Polish (requires repeated form): |
750 | /// {1:form0|%100=[10,20]:form2|%10=[2,4]:form1|:form2} |
751 | static void HandlePluralModifier(const Diagnostic &DInfo, unsigned ValNo, |
752 | const char *Argument, unsigned ArgumentLen, |
753 | SmallVectorImpl<char> &OutStr) { |
754 | const char *ArgumentEnd = Argument + ArgumentLen; |
755 | while (true) { |
756 | assert(Argument < ArgumentEnd && "Plural expression didn't match." ); |
757 | const char *ExprEnd = Argument; |
758 | while (*ExprEnd != ':') { |
759 | assert(ExprEnd != ArgumentEnd && "Plural missing expression end" ); |
760 | ++ExprEnd; |
761 | } |
762 | if (EvalPluralExpr(ValNo, Start: Argument, End: ExprEnd)) { |
763 | Argument = ExprEnd + 1; |
764 | ExprEnd = ScanFormat(I: Argument, E: ArgumentEnd, Target: '|'); |
765 | |
766 | // Recursively format the result of the plural clause into the |
767 | // output string. |
768 | DInfo.FormatDiagnostic(DiagStr: Argument, DiagEnd: ExprEnd, OutStr); |
769 | return; |
770 | } |
771 | Argument = ScanFormat(I: Argument, E: ArgumentEnd - 1, Target: '|') + 1; |
772 | } |
773 | } |
774 | |
775 | /// Returns the friendly description for a token kind that will appear |
776 | /// without quotes in diagnostic messages. These strings may be translatable in |
777 | /// future. |
778 | static const char *getTokenDescForDiagnostic(tok::TokenKind Kind) { |
779 | switch (Kind) { |
780 | case tok::identifier: |
781 | return "identifier" ; |
782 | default: |
783 | return nullptr; |
784 | } |
785 | } |
786 | |
787 | /// FormatDiagnostic - Format this diagnostic into a string, substituting the |
788 | /// formal arguments into the %0 slots. The result is appended onto the Str |
789 | /// array. |
790 | void Diagnostic:: |
791 | FormatDiagnostic(SmallVectorImpl<char> &OutStr) const { |
792 | if (StoredDiagMessage.has_value()) { |
793 | OutStr.append(in_start: StoredDiagMessage->begin(), in_end: StoredDiagMessage->end()); |
794 | return; |
795 | } |
796 | |
797 | StringRef Diag = |
798 | getDiags()->getDiagnosticIDs()->getDescription(DiagID: getID()); |
799 | |
800 | FormatDiagnostic(DiagStr: Diag.begin(), DiagEnd: Diag.end(), OutStr); |
801 | } |
802 | |
803 | /// EscapeStringForDiagnostic - Append Str to the diagnostic buffer, |
804 | /// escaping non-printable characters and ill-formed code unit sequences. |
805 | void clang::EscapeStringForDiagnostic(StringRef Str, |
806 | SmallVectorImpl<char> &OutStr) { |
807 | OutStr.reserve(N: OutStr.size() + Str.size()); |
808 | auto *Begin = reinterpret_cast<const unsigned char *>(Str.data()); |
809 | llvm::raw_svector_ostream OutStream(OutStr); |
810 | const unsigned char *End = Begin + Str.size(); |
811 | while (Begin != End) { |
812 | // ASCII case |
813 | if (isPrintable(c: *Begin) || isWhitespace(c: *Begin)) { |
814 | OutStream << *Begin; |
815 | ++Begin; |
816 | continue; |
817 | } |
818 | if (llvm::isLegalUTF8Sequence(source: Begin, sourceEnd: End)) { |
819 | llvm::UTF32 CodepointValue; |
820 | llvm::UTF32 *CpPtr = &CodepointValue; |
821 | const unsigned char *CodepointBegin = Begin; |
822 | const unsigned char *CodepointEnd = |
823 | Begin + llvm::getNumBytesForUTF8(firstByte: *Begin); |
824 | llvm::ConversionResult Res = llvm::ConvertUTF8toUTF32( |
825 | sourceStart: &Begin, sourceEnd: CodepointEnd, targetStart: &CpPtr, targetEnd: CpPtr + 1, flags: llvm::strictConversion); |
826 | (void)Res; |
827 | assert( |
828 | llvm::conversionOK == Res && |
829 | "the sequence is legal UTF-8 but we couldn't convert it to UTF-32" ); |
830 | assert(Begin == CodepointEnd && |
831 | "we must be further along in the string now" ); |
832 | if (llvm::sys::unicode::isPrintable(UCS: CodepointValue) || |
833 | llvm::sys::unicode::isFormatting(UCS: CodepointValue)) { |
834 | OutStr.append(in_start: CodepointBegin, in_end: CodepointEnd); |
835 | continue; |
836 | } |
837 | // Unprintable code point. |
838 | OutStream << "<U+" << llvm::format_hex_no_prefix(N: CodepointValue, Width: 4, Upper: true) |
839 | << ">" ; |
840 | continue; |
841 | } |
842 | // Invalid code unit. |
843 | OutStream << "<" << llvm::format_hex_no_prefix(N: *Begin, Width: 2, Upper: true) << ">" ; |
844 | ++Begin; |
845 | } |
846 | } |
847 | |
848 | void Diagnostic:: |
849 | FormatDiagnostic(const char *DiagStr, const char *DiagEnd, |
850 | SmallVectorImpl<char> &OutStr) const { |
851 | // When the diagnostic string is only "%0", the entire string is being given |
852 | // by an outside source. Remove unprintable characters from this string |
853 | // and skip all the other string processing. |
854 | if (DiagEnd - DiagStr == 2 && |
855 | StringRef(DiagStr, DiagEnd - DiagStr).equals(RHS: "%0" ) && |
856 | getArgKind(Idx: 0) == DiagnosticsEngine::ak_std_string) { |
857 | const std::string &S = getArgStdStr(Idx: 0); |
858 | EscapeStringForDiagnostic(Str: S, OutStr); |
859 | return; |
860 | } |
861 | |
862 | /// FormattedArgs - Keep track of all of the arguments formatted by |
863 | /// ConvertArgToString and pass them into subsequent calls to |
864 | /// ConvertArgToString, allowing the implementation to avoid redundancies in |
865 | /// obvious cases. |
866 | SmallVector<DiagnosticsEngine::ArgumentValue, 8> FormattedArgs; |
867 | |
868 | /// QualTypeVals - Pass a vector of arrays so that QualType names can be |
869 | /// compared to see if more information is needed to be printed. |
870 | SmallVector<intptr_t, 2> QualTypeVals; |
871 | SmallString<64> Tree; |
872 | |
873 | for (unsigned i = 0, e = getNumArgs(); i < e; ++i) |
874 | if (getArgKind(Idx: i) == DiagnosticsEngine::ak_qualtype) |
875 | QualTypeVals.push_back(Elt: getRawArg(Idx: i)); |
876 | |
877 | while (DiagStr != DiagEnd) { |
878 | if (DiagStr[0] != '%') { |
879 | // Append non-%0 substrings to Str if we have one. |
880 | const char *StrEnd = std::find(first: DiagStr, last: DiagEnd, val: '%'); |
881 | OutStr.append(in_start: DiagStr, in_end: StrEnd); |
882 | DiagStr = StrEnd; |
883 | continue; |
884 | } else if (isPunctuation(c: DiagStr[1])) { |
885 | OutStr.push_back(Elt: DiagStr[1]); // %% -> %. |
886 | DiagStr += 2; |
887 | continue; |
888 | } |
889 | |
890 | // Skip the %. |
891 | ++DiagStr; |
892 | |
893 | // This must be a placeholder for a diagnostic argument. The format for a |
894 | // placeholder is one of "%0", "%modifier0", or "%modifier{arguments}0". |
895 | // The digit is a number from 0-9 indicating which argument this comes from. |
896 | // The modifier is a string of digits from the set [-a-z]+, arguments is a |
897 | // brace enclosed string. |
898 | const char *Modifier = nullptr, *Argument = nullptr; |
899 | unsigned ModifierLen = 0, ArgumentLen = 0; |
900 | |
901 | // Check to see if we have a modifier. If so eat it. |
902 | if (!isDigit(c: DiagStr[0])) { |
903 | Modifier = DiagStr; |
904 | while (DiagStr[0] == '-' || |
905 | (DiagStr[0] >= 'a' && DiagStr[0] <= 'z')) |
906 | ++DiagStr; |
907 | ModifierLen = DiagStr-Modifier; |
908 | |
909 | // If we have an argument, get it next. |
910 | if (DiagStr[0] == '{') { |
911 | ++DiagStr; // Skip {. |
912 | Argument = DiagStr; |
913 | |
914 | DiagStr = ScanFormat(I: DiagStr, E: DiagEnd, Target: '}'); |
915 | assert(DiagStr != DiagEnd && "Mismatched {}'s in diagnostic string!" ); |
916 | ArgumentLen = DiagStr-Argument; |
917 | ++DiagStr; // Skip }. |
918 | } |
919 | } |
920 | |
921 | assert(isDigit(*DiagStr) && "Invalid format for argument in diagnostic" ); |
922 | unsigned ArgNo = *DiagStr++ - '0'; |
923 | |
924 | // Only used for type diffing. |
925 | unsigned ArgNo2 = ArgNo; |
926 | |
927 | DiagnosticsEngine::ArgumentKind Kind = getArgKind(Idx: ArgNo); |
928 | if (ModifierIs(Modifier, ModifierLen, Str: "diff" )) { |
929 | assert(*DiagStr == ',' && isDigit(*(DiagStr + 1)) && |
930 | "Invalid format for diff modifier" ); |
931 | ++DiagStr; // Comma. |
932 | ArgNo2 = *DiagStr++ - '0'; |
933 | DiagnosticsEngine::ArgumentKind Kind2 = getArgKind(Idx: ArgNo2); |
934 | if (Kind == DiagnosticsEngine::ak_qualtype && |
935 | Kind2 == DiagnosticsEngine::ak_qualtype) |
936 | Kind = DiagnosticsEngine::ak_qualtype_pair; |
937 | else { |
938 | // %diff only supports QualTypes. For other kinds of arguments, |
939 | // use the default printing. For example, if the modifier is: |
940 | // "%diff{compare $ to $|other text}1,2" |
941 | // treat it as: |
942 | // "compare %1 to %2" |
943 | const char *ArgumentEnd = Argument + ArgumentLen; |
944 | const char *Pipe = ScanFormat(I: Argument, E: ArgumentEnd, Target: '|'); |
945 | assert(ScanFormat(Pipe + 1, ArgumentEnd, '|') == ArgumentEnd && |
946 | "Found too many '|'s in a %diff modifier!" ); |
947 | const char *FirstDollar = ScanFormat(I: Argument, E: Pipe, Target: '$'); |
948 | const char *SecondDollar = ScanFormat(I: FirstDollar + 1, E: Pipe, Target: '$'); |
949 | const char ArgStr1[] = { '%', static_cast<char>('0' + ArgNo) }; |
950 | const char ArgStr2[] = { '%', static_cast<char>('0' + ArgNo2) }; |
951 | FormatDiagnostic(DiagStr: Argument, DiagEnd: FirstDollar, OutStr); |
952 | FormatDiagnostic(DiagStr: ArgStr1, DiagEnd: ArgStr1 + 2, OutStr); |
953 | FormatDiagnostic(DiagStr: FirstDollar + 1, DiagEnd: SecondDollar, OutStr); |
954 | FormatDiagnostic(DiagStr: ArgStr2, DiagEnd: ArgStr2 + 2, OutStr); |
955 | FormatDiagnostic(DiagStr: SecondDollar + 1, DiagEnd: Pipe, OutStr); |
956 | continue; |
957 | } |
958 | } |
959 | |
960 | switch (Kind) { |
961 | // ---- STRINGS ---- |
962 | case DiagnosticsEngine::ak_std_string: { |
963 | const std::string &S = getArgStdStr(Idx: ArgNo); |
964 | assert(ModifierLen == 0 && "No modifiers for strings yet" ); |
965 | EscapeStringForDiagnostic(Str: S, OutStr); |
966 | break; |
967 | } |
968 | case DiagnosticsEngine::ak_c_string: { |
969 | const char *S = getArgCStr(Idx: ArgNo); |
970 | assert(ModifierLen == 0 && "No modifiers for strings yet" ); |
971 | |
972 | // Don't crash if get passed a null pointer by accident. |
973 | if (!S) |
974 | S = "(null)" ; |
975 | EscapeStringForDiagnostic(Str: S, OutStr); |
976 | break; |
977 | } |
978 | // ---- INTEGERS ---- |
979 | case DiagnosticsEngine::ak_sint: { |
980 | int64_t Val = getArgSInt(Idx: ArgNo); |
981 | |
982 | if (ModifierIs(Modifier, ModifierLen, Str: "select" )) { |
983 | HandleSelectModifier(DInfo: *this, ValNo: (unsigned)Val, Argument, ArgumentLen, |
984 | OutStr); |
985 | } else if (ModifierIs(Modifier, ModifierLen, Str: "s" )) { |
986 | HandleIntegerSModifier(ValNo: Val, OutStr); |
987 | } else if (ModifierIs(Modifier, ModifierLen, Str: "plural" )) { |
988 | HandlePluralModifier(DInfo: *this, ValNo: (unsigned)Val, Argument, ArgumentLen, |
989 | OutStr); |
990 | } else if (ModifierIs(Modifier, ModifierLen, Str: "ordinal" )) { |
991 | HandleOrdinalModifier(ValNo: (unsigned)Val, OutStr); |
992 | } else { |
993 | assert(ModifierLen == 0 && "Unknown integer modifier" ); |
994 | llvm::raw_svector_ostream(OutStr) << Val; |
995 | } |
996 | break; |
997 | } |
998 | case DiagnosticsEngine::ak_uint: { |
999 | uint64_t Val = getArgUInt(Idx: ArgNo); |
1000 | |
1001 | if (ModifierIs(Modifier, ModifierLen, Str: "select" )) { |
1002 | HandleSelectModifier(DInfo: *this, ValNo: Val, Argument, ArgumentLen, OutStr); |
1003 | } else if (ModifierIs(Modifier, ModifierLen, Str: "s" )) { |
1004 | HandleIntegerSModifier(ValNo: Val, OutStr); |
1005 | } else if (ModifierIs(Modifier, ModifierLen, Str: "plural" )) { |
1006 | HandlePluralModifier(DInfo: *this, ValNo: (unsigned)Val, Argument, ArgumentLen, |
1007 | OutStr); |
1008 | } else if (ModifierIs(Modifier, ModifierLen, Str: "ordinal" )) { |
1009 | HandleOrdinalModifier(ValNo: Val, OutStr); |
1010 | } else { |
1011 | assert(ModifierLen == 0 && "Unknown integer modifier" ); |
1012 | llvm::raw_svector_ostream(OutStr) << Val; |
1013 | } |
1014 | break; |
1015 | } |
1016 | // ---- TOKEN SPELLINGS ---- |
1017 | case DiagnosticsEngine::ak_tokenkind: { |
1018 | tok::TokenKind Kind = static_cast<tok::TokenKind>(getRawArg(Idx: ArgNo)); |
1019 | assert(ModifierLen == 0 && "No modifiers for token kinds yet" ); |
1020 | |
1021 | llvm::raw_svector_ostream Out(OutStr); |
1022 | if (const char *S = tok::getPunctuatorSpelling(Kind)) |
1023 | // Quoted token spelling for punctuators. |
1024 | Out << '\'' << S << '\''; |
1025 | else if ((S = tok::getKeywordSpelling(Kind))) |
1026 | // Unquoted token spelling for keywords. |
1027 | Out << S; |
1028 | else if ((S = getTokenDescForDiagnostic(Kind))) |
1029 | // Unquoted translatable token name. |
1030 | Out << S; |
1031 | else if ((S = tok::getTokenName(Kind))) |
1032 | // Debug name, shouldn't appear in user-facing diagnostics. |
1033 | Out << '<' << S << '>'; |
1034 | else |
1035 | Out << "(null)" ; |
1036 | break; |
1037 | } |
1038 | // ---- NAMES and TYPES ---- |
1039 | case DiagnosticsEngine::ak_identifierinfo: { |
1040 | const IdentifierInfo *II = getArgIdentifier(Idx: ArgNo); |
1041 | assert(ModifierLen == 0 && "No modifiers for strings yet" ); |
1042 | |
1043 | // Don't crash if get passed a null pointer by accident. |
1044 | if (!II) { |
1045 | const char *S = "(null)" ; |
1046 | OutStr.append(in_start: S, in_end: S + strlen(s: S)); |
1047 | continue; |
1048 | } |
1049 | |
1050 | llvm::raw_svector_ostream(OutStr) << '\'' << II->getName() << '\''; |
1051 | break; |
1052 | } |
1053 | case DiagnosticsEngine::ak_addrspace: |
1054 | case DiagnosticsEngine::ak_qual: |
1055 | case DiagnosticsEngine::ak_qualtype: |
1056 | case DiagnosticsEngine::ak_declarationname: |
1057 | case DiagnosticsEngine::ak_nameddecl: |
1058 | case DiagnosticsEngine::ak_nestednamespec: |
1059 | case DiagnosticsEngine::ak_declcontext: |
1060 | case DiagnosticsEngine::ak_attr: |
1061 | getDiags()->ConvertArgToString(Kind, Val: getRawArg(Idx: ArgNo), |
1062 | Modifier: StringRef(Modifier, ModifierLen), |
1063 | Argument: StringRef(Argument, ArgumentLen), |
1064 | PrevArgs: FormattedArgs, |
1065 | Output&: OutStr, QualTypeVals); |
1066 | break; |
1067 | case DiagnosticsEngine::ak_qualtype_pair: { |
1068 | // Create a struct with all the info needed for printing. |
1069 | TemplateDiffTypes TDT; |
1070 | TDT.FromType = getRawArg(Idx: ArgNo); |
1071 | TDT.ToType = getRawArg(Idx: ArgNo2); |
1072 | TDT.ElideType = getDiags()->ElideType; |
1073 | TDT.ShowColors = getDiags()->ShowColors; |
1074 | TDT.TemplateDiffUsed = false; |
1075 | intptr_t val = reinterpret_cast<intptr_t>(&TDT); |
1076 | |
1077 | const char *ArgumentEnd = Argument + ArgumentLen; |
1078 | const char *Pipe = ScanFormat(I: Argument, E: ArgumentEnd, Target: '|'); |
1079 | |
1080 | // Print the tree. If this diagnostic already has a tree, skip the |
1081 | // second tree. |
1082 | if (getDiags()->PrintTemplateTree && Tree.empty()) { |
1083 | TDT.PrintFromType = true; |
1084 | TDT.PrintTree = true; |
1085 | getDiags()->ConvertArgToString(Kind, Val: val, |
1086 | Modifier: StringRef(Modifier, ModifierLen), |
1087 | Argument: StringRef(Argument, ArgumentLen), |
1088 | PrevArgs: FormattedArgs, |
1089 | Output&: Tree, QualTypeVals); |
1090 | // If there is no tree information, fall back to regular printing. |
1091 | if (!Tree.empty()) { |
1092 | FormatDiagnostic(DiagStr: Pipe + 1, DiagEnd: ArgumentEnd, OutStr); |
1093 | break; |
1094 | } |
1095 | } |
1096 | |
1097 | // Non-tree printing, also the fall-back when tree printing fails. |
1098 | // The fall-back is triggered when the types compared are not templates. |
1099 | const char *FirstDollar = ScanFormat(I: Argument, E: ArgumentEnd, Target: '$'); |
1100 | const char *SecondDollar = ScanFormat(I: FirstDollar + 1, E: ArgumentEnd, Target: '$'); |
1101 | |
1102 | // Append before text |
1103 | FormatDiagnostic(DiagStr: Argument, DiagEnd: FirstDollar, OutStr); |
1104 | |
1105 | // Append first type |
1106 | TDT.PrintTree = false; |
1107 | TDT.PrintFromType = true; |
1108 | getDiags()->ConvertArgToString(Kind, Val: val, |
1109 | Modifier: StringRef(Modifier, ModifierLen), |
1110 | Argument: StringRef(Argument, ArgumentLen), |
1111 | PrevArgs: FormattedArgs, |
1112 | Output&: OutStr, QualTypeVals); |
1113 | if (!TDT.TemplateDiffUsed) |
1114 | FormattedArgs.push_back(Elt: std::make_pair(x: DiagnosticsEngine::ak_qualtype, |
1115 | y&: TDT.FromType)); |
1116 | |
1117 | // Append middle text |
1118 | FormatDiagnostic(DiagStr: FirstDollar + 1, DiagEnd: SecondDollar, OutStr); |
1119 | |
1120 | // Append second type |
1121 | TDT.PrintFromType = false; |
1122 | getDiags()->ConvertArgToString(Kind, Val: val, |
1123 | Modifier: StringRef(Modifier, ModifierLen), |
1124 | Argument: StringRef(Argument, ArgumentLen), |
1125 | PrevArgs: FormattedArgs, |
1126 | Output&: OutStr, QualTypeVals); |
1127 | if (!TDT.TemplateDiffUsed) |
1128 | FormattedArgs.push_back(Elt: std::make_pair(x: DiagnosticsEngine::ak_qualtype, |
1129 | y&: TDT.ToType)); |
1130 | |
1131 | // Append end text |
1132 | FormatDiagnostic(DiagStr: SecondDollar + 1, DiagEnd: Pipe, OutStr); |
1133 | break; |
1134 | } |
1135 | } |
1136 | |
1137 | // Remember this argument info for subsequent formatting operations. Turn |
1138 | // std::strings into a null terminated string to make it be the same case as |
1139 | // all the other ones. |
1140 | if (Kind == DiagnosticsEngine::ak_qualtype_pair) |
1141 | continue; |
1142 | else if (Kind != DiagnosticsEngine::ak_std_string) |
1143 | FormattedArgs.push_back(Elt: std::make_pair(x&: Kind, y: getRawArg(Idx: ArgNo))); |
1144 | else |
1145 | FormattedArgs.push_back(Elt: std::make_pair(x: DiagnosticsEngine::ak_c_string, |
1146 | y: (intptr_t)getArgStdStr(Idx: ArgNo).c_str())); |
1147 | } |
1148 | |
1149 | // Append the type tree to the end of the diagnostics. |
1150 | OutStr.append(in_start: Tree.begin(), in_end: Tree.end()); |
1151 | } |
1152 | |
1153 | StoredDiagnostic::StoredDiagnostic(DiagnosticsEngine::Level Level, unsigned ID, |
1154 | StringRef Message) |
1155 | : ID(ID), Level(Level), Message(Message) {} |
1156 | |
1157 | StoredDiagnostic::StoredDiagnostic(DiagnosticsEngine::Level Level, |
1158 | const Diagnostic &Info) |
1159 | : ID(Info.getID()), Level(Level) { |
1160 | assert((Info.getLocation().isInvalid() || Info.hasSourceManager()) && |
1161 | "Valid source location without setting a source manager for diagnostic" ); |
1162 | if (Info.getLocation().isValid()) |
1163 | Loc = FullSourceLoc(Info.getLocation(), Info.getSourceManager()); |
1164 | SmallString<64> Message; |
1165 | Info.FormatDiagnostic(OutStr&: Message); |
1166 | this->Message.assign(first: Message.begin(), last: Message.end()); |
1167 | this->Ranges.assign(first: Info.getRanges().begin(), last: Info.getRanges().end()); |
1168 | this->FixIts.assign(first: Info.getFixItHints().begin(), last: Info.getFixItHints().end()); |
1169 | } |
1170 | |
1171 | StoredDiagnostic::StoredDiagnostic(DiagnosticsEngine::Level Level, unsigned ID, |
1172 | StringRef Message, FullSourceLoc Loc, |
1173 | ArrayRef<CharSourceRange> Ranges, |
1174 | ArrayRef<FixItHint> FixIts) |
1175 | : ID(ID), Level(Level), Loc(Loc), Message(Message), |
1176 | Ranges(Ranges.begin(), Ranges.end()), FixIts(FixIts.begin(), FixIts.end()) |
1177 | { |
1178 | } |
1179 | |
1180 | llvm::raw_ostream &clang::operator<<(llvm::raw_ostream &OS, |
1181 | const StoredDiagnostic &SD) { |
1182 | if (SD.getLocation().hasManager()) |
1183 | OS << SD.getLocation().printToString(SM: SD.getLocation().getManager()) << ": " ; |
1184 | OS << SD.getMessage(); |
1185 | return OS; |
1186 | } |
1187 | |
1188 | /// IncludeInDiagnosticCounts - This method (whose default implementation |
1189 | /// returns true) indicates whether the diagnostics handled by this |
1190 | /// DiagnosticConsumer should be included in the number of diagnostics |
1191 | /// reported by DiagnosticsEngine. |
1192 | bool DiagnosticConsumer::IncludeInDiagnosticCounts() const { return true; } |
1193 | |
1194 | void IgnoringDiagConsumer::anchor() {} |
1195 | |
1196 | ForwardingDiagnosticConsumer::~ForwardingDiagnosticConsumer() = default; |
1197 | |
1198 | void ForwardingDiagnosticConsumer::HandleDiagnostic( |
1199 | DiagnosticsEngine::Level DiagLevel, |
1200 | const Diagnostic &Info) { |
1201 | Target.HandleDiagnostic(DiagLevel, Info); |
1202 | } |
1203 | |
1204 | void ForwardingDiagnosticConsumer::clear() { |
1205 | DiagnosticConsumer::clear(); |
1206 | Target.clear(); |
1207 | } |
1208 | |
1209 | bool ForwardingDiagnosticConsumer::IncludeInDiagnosticCounts() const { |
1210 | return Target.IncludeInDiagnosticCounts(); |
1211 | } |
1212 | |
1213 | PartialDiagnostic::DiagStorageAllocator::DiagStorageAllocator() { |
1214 | for (unsigned I = 0; I != NumCached; ++I) |
1215 | FreeList[I] = Cached + I; |
1216 | NumFreeListEntries = NumCached; |
1217 | } |
1218 | |
1219 | PartialDiagnostic::DiagStorageAllocator::~DiagStorageAllocator() { |
1220 | // Don't assert if we are in a CrashRecovery context, as this invariant may |
1221 | // be invalidated during a crash. |
1222 | assert((NumFreeListEntries == NumCached || |
1223 | llvm::CrashRecoveryContext::isRecoveringFromCrash()) && |
1224 | "A partial is on the lam" ); |
1225 | } |
1226 | |
1227 | char DiagnosticError::ID; |
1228 | |