|
150
|
1 //===--- DiagnosticIDs.cpp - Diagnostic IDs 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 IDs-related interfaces.
|
|
|
10 //
|
|
|
11 //===----------------------------------------------------------------------===//
|
|
|
12
|
|
|
13 #include "clang/Basic/DiagnosticIDs.h"
|
|
|
14 #include "clang/Basic/AllDiagnostics.h"
|
|
|
15 #include "clang/Basic/DiagnosticCategories.h"
|
|
|
16 #include "clang/Basic/SourceManager.h"
|
|
|
17 #include "llvm/ADT/STLExtras.h"
|
|
|
18 #include "llvm/ADT/SmallVector.h"
|
|
|
19 #include "llvm/Support/ErrorHandling.h"
|
|
|
20 #include <map>
|
|
|
21 using namespace clang;
|
|
|
22
|
|
|
23 //===----------------------------------------------------------------------===//
|
|
|
24 // Builtin Diagnostic information
|
|
|
25 //===----------------------------------------------------------------------===//
|
|
|
26
|
|
|
27 namespace {
|
|
|
28
|
|
|
29 // Diagnostic classes.
|
|
|
30 enum {
|
|
|
31 CLASS_NOTE = 0x01,
|
|
|
32 CLASS_REMARK = 0x02,
|
|
|
33 CLASS_WARNING = 0x03,
|
|
|
34 CLASS_EXTENSION = 0x04,
|
|
|
35 CLASS_ERROR = 0x05
|
|
|
36 };
|
|
|
37
|
|
|
38 struct StaticDiagInfoRec {
|
|
|
39 uint16_t DiagID;
|
|
|
40 unsigned DefaultSeverity : 3;
|
|
|
41 unsigned Class : 3;
|
|
|
42 unsigned SFINAE : 2;
|
|
|
43 unsigned WarnNoWerror : 1;
|
|
|
44 unsigned WarnShowInSystemHeader : 1;
|
|
|
45 unsigned Category : 6;
|
|
|
46
|
|
|
47 uint16_t OptionGroupIndex;
|
|
|
48
|
|
|
49 uint16_t DescriptionLen;
|
|
|
50 const char *DescriptionStr;
|
|
|
51
|
|
|
52 unsigned getOptionGroupIndex() const {
|
|
|
53 return OptionGroupIndex;
|
|
|
54 }
|
|
|
55
|
|
|
56 StringRef getDescription() const {
|
|
|
57 return StringRef(DescriptionStr, DescriptionLen);
|
|
|
58 }
|
|
|
59
|
|
|
60 diag::Flavor getFlavor() const {
|
|
|
61 return Class == CLASS_REMARK ? diag::Flavor::Remark
|
|
|
62 : diag::Flavor::WarningOrError;
|
|
|
63 }
|
|
|
64
|
|
|
65 bool operator<(const StaticDiagInfoRec &RHS) const {
|
|
|
66 return DiagID < RHS.DiagID;
|
|
|
67 }
|
|
|
68 };
|
|
|
69
|
|
|
70 #define STRINGIFY_NAME(NAME) #NAME
|
|
|
71 #define VALIDATE_DIAG_SIZE(NAME) \
|
|
|
72 static_assert( \
|
|
|
73 static_cast<unsigned>(diag::NUM_BUILTIN_##NAME##_DIAGNOSTICS) < \
|
|
|
74 static_cast<unsigned>(diag::DIAG_START_##NAME) + \
|
|
|
75 static_cast<unsigned>(diag::DIAG_SIZE_##NAME), \
|
|
|
76 STRINGIFY_NAME( \
|
|
|
77 DIAG_SIZE_##NAME) " is insufficient to contain all " \
|
|
|
78 "diagnostics, it may need to be made larger in " \
|
|
|
79 "DiagnosticIDs.h.");
|
|
|
80 VALIDATE_DIAG_SIZE(COMMON)
|
|
|
81 VALIDATE_DIAG_SIZE(DRIVER)
|
|
|
82 VALIDATE_DIAG_SIZE(FRONTEND)
|
|
|
83 VALIDATE_DIAG_SIZE(SERIALIZATION)
|
|
|
84 VALIDATE_DIAG_SIZE(LEX)
|
|
|
85 VALIDATE_DIAG_SIZE(PARSE)
|
|
|
86 VALIDATE_DIAG_SIZE(AST)
|
|
|
87 VALIDATE_DIAG_SIZE(COMMENT)
|
|
|
88 VALIDATE_DIAG_SIZE(SEMA)
|
|
|
89 VALIDATE_DIAG_SIZE(ANALYSIS)
|
|
|
90 VALIDATE_DIAG_SIZE(REFACTORING)
|
|
|
91 #undef VALIDATE_DIAG_SIZE
|
|
|
92 #undef STRINGIFY_NAME
|
|
|
93
|
|
|
94 } // namespace anonymous
|
|
|
95
|
|
|
96 static const StaticDiagInfoRec StaticDiagInfo[] = {
|
|
|
97 #define DIAG(ENUM, CLASS, DEFAULT_SEVERITY, DESC, GROUP, SFINAE, NOWERROR, \
|
|
|
98 SHOWINSYSHEADER, CATEGORY) \
|
|
|
99 { \
|
|
|
100 diag::ENUM, DEFAULT_SEVERITY, CLASS, DiagnosticIDs::SFINAE, NOWERROR, \
|
|
|
101 SHOWINSYSHEADER, CATEGORY, GROUP, STR_SIZE(DESC, uint16_t), DESC \
|
|
|
102 } \
|
|
|
103 ,
|
|
|
104 #include "clang/Basic/DiagnosticCommonKinds.inc"
|
|
|
105 #include "clang/Basic/DiagnosticDriverKinds.inc"
|
|
|
106 #include "clang/Basic/DiagnosticFrontendKinds.inc"
|
|
|
107 #include "clang/Basic/DiagnosticSerializationKinds.inc"
|
|
|
108 #include "clang/Basic/DiagnosticLexKinds.inc"
|
|
|
109 #include "clang/Basic/DiagnosticParseKinds.inc"
|
|
|
110 #include "clang/Basic/DiagnosticASTKinds.inc"
|
|
|
111 #include "clang/Basic/DiagnosticCommentKinds.inc"
|
|
|
112 #include "clang/Basic/DiagnosticCrossTUKinds.inc"
|
|
|
113 #include "clang/Basic/DiagnosticSemaKinds.inc"
|
|
|
114 #include "clang/Basic/DiagnosticAnalysisKinds.inc"
|
|
|
115 #include "clang/Basic/DiagnosticRefactoringKinds.inc"
|
|
|
116 #undef DIAG
|
|
|
117 };
|
|
|
118
|
|
|
119 static const unsigned StaticDiagInfoSize = llvm::array_lengthof(StaticDiagInfo);
|
|
|
120
|
|
|
121 /// GetDiagInfo - Return the StaticDiagInfoRec entry for the specified DiagID,
|
|
|
122 /// or null if the ID is invalid.
|
|
|
123 static const StaticDiagInfoRec *GetDiagInfo(unsigned DiagID) {
|
|
|
124 // Out of bounds diag. Can't be in the table.
|
|
|
125 using namespace diag;
|
|
|
126 if (DiagID >= DIAG_UPPER_LIMIT || DiagID <= DIAG_START_COMMON)
|
|
|
127 return nullptr;
|
|
|
128
|
|
|
129 // Compute the index of the requested diagnostic in the static table.
|
|
|
130 // 1. Add the number of diagnostics in each category preceding the
|
|
|
131 // diagnostic and of the category the diagnostic is in. This gives us
|
|
|
132 // the offset of the category in the table.
|
|
|
133 // 2. Subtract the number of IDs in each category from our ID. This gives us
|
|
|
134 // the offset of the diagnostic in the category.
|
|
|
135 // This is cheaper than a binary search on the table as it doesn't touch
|
|
|
136 // memory at all.
|
|
|
137 unsigned Offset = 0;
|
|
|
138 unsigned ID = DiagID - DIAG_START_COMMON - 1;
|
|
|
139 #define CATEGORY(NAME, PREV) \
|
|
|
140 if (DiagID > DIAG_START_##NAME) { \
|
|
|
141 Offset += NUM_BUILTIN_##PREV##_DIAGNOSTICS - DIAG_START_##PREV - 1; \
|
|
|
142 ID -= DIAG_START_##NAME - DIAG_START_##PREV; \
|
|
|
143 }
|
|
|
144 CATEGORY(DRIVER, COMMON)
|
|
|
145 CATEGORY(FRONTEND, DRIVER)
|
|
|
146 CATEGORY(SERIALIZATION, FRONTEND)
|
|
|
147 CATEGORY(LEX, SERIALIZATION)
|
|
|
148 CATEGORY(PARSE, LEX)
|
|
|
149 CATEGORY(AST, PARSE)
|
|
|
150 CATEGORY(COMMENT, AST)
|
|
|
151 CATEGORY(CROSSTU, COMMENT)
|
|
|
152 CATEGORY(SEMA, CROSSTU)
|
|
|
153 CATEGORY(ANALYSIS, SEMA)
|
|
|
154 CATEGORY(REFACTORING, ANALYSIS)
|
|
|
155 #undef CATEGORY
|
|
|
156
|
|
|
157 // Avoid out of bounds reads.
|
|
|
158 if (ID + Offset >= StaticDiagInfoSize)
|
|
|
159 return nullptr;
|
|
|
160
|
|
|
161 assert(ID < StaticDiagInfoSize && Offset < StaticDiagInfoSize);
|
|
|
162
|
|
|
163 const StaticDiagInfoRec *Found = &StaticDiagInfo[ID + Offset];
|
|
|
164 // If the diag id doesn't match we found a different diag, abort. This can
|
|
|
165 // happen when this function is called with an ID that points into a hole in
|
|
|
166 // the diagID space.
|
|
|
167 if (Found->DiagID != DiagID)
|
|
|
168 return nullptr;
|
|
|
169 return Found;
|
|
|
170 }
|
|
|
171
|
|
|
172 static DiagnosticMapping GetDefaultDiagMapping(unsigned DiagID) {
|
|
|
173 DiagnosticMapping Info = DiagnosticMapping::Make(
|
|
|
174 diag::Severity::Fatal, /*IsUser=*/false, /*IsPragma=*/false);
|
|
|
175
|
|
|
176 if (const StaticDiagInfoRec *StaticInfo = GetDiagInfo(DiagID)) {
|
|
|
177 Info.setSeverity((diag::Severity)StaticInfo->DefaultSeverity);
|
|
|
178
|
|
|
179 if (StaticInfo->WarnNoWerror) {
|
|
|
180 assert(Info.getSeverity() == diag::Severity::Warning &&
|
|
|
181 "Unexpected mapping with no-Werror bit!");
|
|
|
182 Info.setNoWarningAsError(true);
|
|
|
183 }
|
|
|
184 }
|
|
|
185
|
|
|
186 return Info;
|
|
|
187 }
|
|
|
188
|
|
|
189 /// getCategoryNumberForDiag - Return the category number that a specified
|
|
|
190 /// DiagID belongs to, or 0 if no category.
|
|
|
191 unsigned DiagnosticIDs::getCategoryNumberForDiag(unsigned DiagID) {
|
|
|
192 if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
|
|
|
193 return Info->Category;
|
|
|
194 return 0;
|
|
|
195 }
|
|
|
196
|
|
|
197 namespace {
|
|
|
198 // The diagnostic category names.
|
|
|
199 struct StaticDiagCategoryRec {
|
|
|
200 const char *NameStr;
|
|
|
201 uint8_t NameLen;
|
|
|
202
|
|
|
203 StringRef getName() const {
|
|
|
204 return StringRef(NameStr, NameLen);
|
|
|
205 }
|
|
|
206 };
|
|
|
207 }
|
|
|
208
|
|
|
209 // Unfortunately, the split between DiagnosticIDs and Diagnostic is not
|
|
|
210 // particularly clean, but for now we just implement this method here so we can
|
|
|
211 // access GetDefaultDiagMapping.
|
|
|
212 DiagnosticMapping &
|
|
|
213 DiagnosticsEngine::DiagState::getOrAddMapping(diag::kind Diag) {
|
|
|
214 std::pair<iterator, bool> Result =
|
|
|
215 DiagMap.insert(std::make_pair(Diag, DiagnosticMapping()));
|
|
|
216
|
|
|
217 // Initialize the entry if we added it.
|
|
|
218 if (Result.second)
|
|
|
219 Result.first->second = GetDefaultDiagMapping(Diag);
|
|
|
220
|
|
|
221 return Result.first->second;
|
|
|
222 }
|
|
|
223
|
|
|
224 static const StaticDiagCategoryRec CategoryNameTable[] = {
|
|
|
225 #define GET_CATEGORY_TABLE
|
|
|
226 #define CATEGORY(X, ENUM) { X, STR_SIZE(X, uint8_t) },
|
|
|
227 #include "clang/Basic/DiagnosticGroups.inc"
|
|
|
228 #undef GET_CATEGORY_TABLE
|
|
|
229 { nullptr, 0 }
|
|
|
230 };
|
|
|
231
|
|
|
232 /// getNumberOfCategories - Return the number of categories
|
|
|
233 unsigned DiagnosticIDs::getNumberOfCategories() {
|
|
|
234 return llvm::array_lengthof(CategoryNameTable) - 1;
|
|
|
235 }
|
|
|
236
|
|
|
237 /// getCategoryNameFromID - Given a category ID, return the name of the
|
|
|
238 /// category, an empty string if CategoryID is zero, or null if CategoryID is
|
|
|
239 /// invalid.
|
|
|
240 StringRef DiagnosticIDs::getCategoryNameFromID(unsigned CategoryID) {
|
|
|
241 if (CategoryID >= getNumberOfCategories())
|
|
|
242 return StringRef();
|
|
|
243 return CategoryNameTable[CategoryID].getName();
|
|
|
244 }
|
|
|
245
|
|
|
246
|
|
|
247
|
|
|
248 DiagnosticIDs::SFINAEResponse
|
|
|
249 DiagnosticIDs::getDiagnosticSFINAEResponse(unsigned DiagID) {
|
|
|
250 if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
|
|
|
251 return static_cast<DiagnosticIDs::SFINAEResponse>(Info->SFINAE);
|
|
|
252 return SFINAE_Report;
|
|
|
253 }
|
|
|
254
|
|
|
255 /// getBuiltinDiagClass - Return the class field of the diagnostic.
|
|
|
256 ///
|
|
|
257 static unsigned getBuiltinDiagClass(unsigned DiagID) {
|
|
|
258 if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
|
|
|
259 return Info->Class;
|
|
|
260 return ~0U;
|
|
|
261 }
|
|
|
262
|
|
|
263 //===----------------------------------------------------------------------===//
|
|
|
264 // Custom Diagnostic information
|
|
|
265 //===----------------------------------------------------------------------===//
|
|
|
266
|
|
|
267 namespace clang {
|
|
|
268 namespace diag {
|
|
|
269 class CustomDiagInfo {
|
|
|
270 typedef std::pair<DiagnosticIDs::Level, std::string> DiagDesc;
|
|
|
271 std::vector<DiagDesc> DiagInfo;
|
|
|
272 std::map<DiagDesc, unsigned> DiagIDs;
|
|
|
273 public:
|
|
|
274
|
|
|
275 /// getDescription - Return the description of the specified custom
|
|
|
276 /// diagnostic.
|
|
|
277 StringRef getDescription(unsigned DiagID) const {
|
|
|
278 assert(DiagID - DIAG_UPPER_LIMIT < DiagInfo.size() &&
|
|
|
279 "Invalid diagnostic ID");
|
|
|
280 return DiagInfo[DiagID-DIAG_UPPER_LIMIT].second;
|
|
|
281 }
|
|
|
282
|
|
|
283 /// getLevel - Return the level of the specified custom diagnostic.
|
|
|
284 DiagnosticIDs::Level getLevel(unsigned DiagID) const {
|
|
|
285 assert(DiagID - DIAG_UPPER_LIMIT < DiagInfo.size() &&
|
|
|
286 "Invalid diagnostic ID");
|
|
|
287 return DiagInfo[DiagID-DIAG_UPPER_LIMIT].first;
|
|
|
288 }
|
|
|
289
|
|
|
290 unsigned getOrCreateDiagID(DiagnosticIDs::Level L, StringRef Message,
|
|
|
291 DiagnosticIDs &Diags) {
|
|
|
292 DiagDesc D(L, std::string(Message));
|
|
|
293 // Check to see if it already exists.
|
|
|
294 std::map<DiagDesc, unsigned>::iterator I = DiagIDs.lower_bound(D);
|
|
|
295 if (I != DiagIDs.end() && I->first == D)
|
|
|
296 return I->second;
|
|
|
297
|
|
|
298 // If not, assign a new ID.
|
|
|
299 unsigned ID = DiagInfo.size()+DIAG_UPPER_LIMIT;
|
|
|
300 DiagIDs.insert(std::make_pair(D, ID));
|
|
|
301 DiagInfo.push_back(D);
|
|
|
302 return ID;
|
|
|
303 }
|
|
|
304 };
|
|
|
305
|
|
|
306 } // end diag namespace
|
|
|
307 } // end clang namespace
|
|
|
308
|
|
|
309
|
|
|
310 //===----------------------------------------------------------------------===//
|
|
|
311 // Common Diagnostic implementation
|
|
|
312 //===----------------------------------------------------------------------===//
|
|
|
313
|
|
|
314 DiagnosticIDs::DiagnosticIDs() {}
|
|
|
315
|
|
|
316 DiagnosticIDs::~DiagnosticIDs() {}
|
|
|
317
|
|
|
318 /// getCustomDiagID - Return an ID for a diagnostic with the specified message
|
|
|
319 /// and level. If this is the first request for this diagnostic, it is
|
|
|
320 /// registered and created, otherwise the existing ID is returned.
|
|
|
321 ///
|
|
|
322 /// \param FormatString A fixed diagnostic format string that will be hashed and
|
|
|
323 /// mapped to a unique DiagID.
|
|
|
324 unsigned DiagnosticIDs::getCustomDiagID(Level L, StringRef FormatString) {
|
|
|
325 if (!CustomDiagInfo)
|
|
|
326 CustomDiagInfo.reset(new diag::CustomDiagInfo());
|
|
|
327 return CustomDiagInfo->getOrCreateDiagID(L, FormatString, *this);
|
|
|
328 }
|
|
|
329
|
|
|
330
|
|
|
331 /// isBuiltinWarningOrExtension - Return true if the unmapped diagnostic
|
|
|
332 /// level of the specified diagnostic ID is a Warning or Extension.
|
|
|
333 /// This only works on builtin diagnostics, not custom ones, and is not legal to
|
|
|
334 /// call on NOTEs.
|
|
|
335 bool DiagnosticIDs::isBuiltinWarningOrExtension(unsigned DiagID) {
|
|
|
336 return DiagID < diag::DIAG_UPPER_LIMIT &&
|
|
|
337 getBuiltinDiagClass(DiagID) != CLASS_ERROR;
|
|
|
338 }
|
|
|
339
|
|
|
340 /// Determine whether the given built-in diagnostic ID is a
|
|
|
341 /// Note.
|
|
|
342 bool DiagnosticIDs::isBuiltinNote(unsigned DiagID) {
|
|
|
343 return DiagID < diag::DIAG_UPPER_LIMIT &&
|
|
|
344 getBuiltinDiagClass(DiagID) == CLASS_NOTE;
|
|
|
345 }
|
|
|
346
|
|
|
347 /// isBuiltinExtensionDiag - Determine whether the given built-in diagnostic
|
|
|
348 /// ID is for an extension of some sort. This also returns EnabledByDefault,
|
|
|
349 /// which is set to indicate whether the diagnostic is ignored by default (in
|
|
|
350 /// which case -pedantic enables it) or treated as a warning/error by default.
|
|
|
351 ///
|
|
|
352 bool DiagnosticIDs::isBuiltinExtensionDiag(unsigned DiagID,
|
|
|
353 bool &EnabledByDefault) {
|
|
|
354 if (DiagID >= diag::DIAG_UPPER_LIMIT ||
|
|
|
355 getBuiltinDiagClass(DiagID) != CLASS_EXTENSION)
|
|
|
356 return false;
|
|
|
357
|
|
|
358 EnabledByDefault =
|
|
|
359 GetDefaultDiagMapping(DiagID).getSeverity() != diag::Severity::Ignored;
|
|
|
360 return true;
|
|
|
361 }
|
|
|
362
|
|
|
363 bool DiagnosticIDs::isDefaultMappingAsError(unsigned DiagID) {
|
|
|
364 if (DiagID >= diag::DIAG_UPPER_LIMIT)
|
|
|
365 return false;
|
|
|
366
|
|
|
367 return GetDefaultDiagMapping(DiagID).getSeverity() >= diag::Severity::Error;
|
|
|
368 }
|
|
|
369
|
|
|
370 /// getDescription - Given a diagnostic ID, return a description of the
|
|
|
371 /// issue.
|
|
|
372 StringRef DiagnosticIDs::getDescription(unsigned DiagID) const {
|
|
|
373 if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
|
|
|
374 return Info->getDescription();
|
|
|
375 assert(CustomDiagInfo && "Invalid CustomDiagInfo");
|
|
|
376 return CustomDiagInfo->getDescription(DiagID);
|
|
|
377 }
|
|
|
378
|
|
|
379 static DiagnosticIDs::Level toLevel(diag::Severity SV) {
|
|
|
380 switch (SV) {
|
|
|
381 case diag::Severity::Ignored:
|
|
|
382 return DiagnosticIDs::Ignored;
|
|
|
383 case diag::Severity::Remark:
|
|
|
384 return DiagnosticIDs::Remark;
|
|
|
385 case diag::Severity::Warning:
|
|
|
386 return DiagnosticIDs::Warning;
|
|
|
387 case diag::Severity::Error:
|
|
|
388 return DiagnosticIDs::Error;
|
|
|
389 case diag::Severity::Fatal:
|
|
|
390 return DiagnosticIDs::Fatal;
|
|
|
391 }
|
|
|
392 llvm_unreachable("unexpected severity");
|
|
|
393 }
|
|
|
394
|
|
|
395 /// getDiagnosticLevel - Based on the way the client configured the
|
|
|
396 /// DiagnosticsEngine object, classify the specified diagnostic ID into a Level,
|
|
|
397 /// by consumable the DiagnosticClient.
|
|
|
398 DiagnosticIDs::Level
|
|
|
399 DiagnosticIDs::getDiagnosticLevel(unsigned DiagID, SourceLocation Loc,
|
|
|
400 const DiagnosticsEngine &Diag) const {
|
|
|
401 // Handle custom diagnostics, which cannot be mapped.
|
|
|
402 if (DiagID >= diag::DIAG_UPPER_LIMIT) {
|
|
|
403 assert(CustomDiagInfo && "Invalid CustomDiagInfo");
|
|
|
404 return CustomDiagInfo->getLevel(DiagID);
|
|
|
405 }
|
|
|
406
|
|
|
407 unsigned DiagClass = getBuiltinDiagClass(DiagID);
|
|
|
408 if (DiagClass == CLASS_NOTE) return DiagnosticIDs::Note;
|
|
|
409 return toLevel(getDiagnosticSeverity(DiagID, Loc, Diag));
|
|
|
410 }
|
|
|
411
|
|
|
412 /// Based on the way the client configured the Diagnostic
|
|
|
413 /// object, classify the specified diagnostic ID into a Level, consumable by
|
|
|
414 /// the DiagnosticClient.
|
|
|
415 ///
|
|
|
416 /// \param Loc The source location we are interested in finding out the
|
|
|
417 /// diagnostic state. Can be null in order to query the latest state.
|
|
|
418 diag::Severity
|
|
|
419 DiagnosticIDs::getDiagnosticSeverity(unsigned DiagID, SourceLocation Loc,
|
|
|
420 const DiagnosticsEngine &Diag) const {
|
|
|
421 assert(getBuiltinDiagClass(DiagID) != CLASS_NOTE);
|
|
|
422
|
|
|
423 // Specific non-error diagnostics may be mapped to various levels from ignored
|
|
|
424 // to error. Errors can only be mapped to fatal.
|
|
|
425 diag::Severity Result = diag::Severity::Fatal;
|
|
|
426
|
|
|
427 // Get the mapping information, or compute it lazily.
|
|
|
428 DiagnosticsEngine::DiagState *State = Diag.GetDiagStateForLoc(Loc);
|
|
|
429 DiagnosticMapping &Mapping = State->getOrAddMapping((diag::kind)DiagID);
|
|
|
430
|
|
|
431 // TODO: Can a null severity really get here?
|
|
|
432 if (Mapping.getSeverity() != diag::Severity())
|
|
|
433 Result = Mapping.getSeverity();
|
|
|
434
|
|
|
435 // Upgrade ignored diagnostics if -Weverything is enabled.
|
|
|
436 if (State->EnableAllWarnings && Result == diag::Severity::Ignored &&
|
|
|
437 !Mapping.isUser() && getBuiltinDiagClass(DiagID) != CLASS_REMARK)
|
|
|
438 Result = diag::Severity::Warning;
|
|
|
439
|
|
|
440 // Ignore -pedantic diagnostics inside __extension__ blocks.
|
|
|
441 // (The diagnostics controlled by -pedantic are the extension diagnostics
|
|
|
442 // that are not enabled by default.)
|
|
|
443 bool EnabledByDefault = false;
|
|
|
444 bool IsExtensionDiag = isBuiltinExtensionDiag(DiagID, EnabledByDefault);
|
|
|
445 if (Diag.AllExtensionsSilenced && IsExtensionDiag && !EnabledByDefault)
|
|
|
446 return diag::Severity::Ignored;
|
|
|
447
|
|
|
448 // For extension diagnostics that haven't been explicitly mapped, check if we
|
|
|
449 // should upgrade the diagnostic.
|
|
|
450 if (IsExtensionDiag && !Mapping.isUser())
|
|
|
451 Result = std::max(Result, State->ExtBehavior);
|
|
|
452
|
|
|
453 // At this point, ignored errors can no longer be upgraded.
|
|
|
454 if (Result == diag::Severity::Ignored)
|
|
|
455 return Result;
|
|
|
456
|
|
|
457 // Honor -w: this disables all messages which which are not Error/Fatal by
|
|
|
458 // default (disregarding attempts to upgrade severity from Warning to Error),
|
|
|
459 // as well as disabling all messages which are currently mapped to Warning
|
|
|
460 // (whether by default or downgraded from Error via e.g. -Wno-error or #pragma
|
|
|
461 // diagnostic.)
|
|
|
462 if (State->IgnoreAllWarnings) {
|
|
|
463 if (Result == diag::Severity::Warning ||
|
|
|
464 (Result >= diag::Severity::Error &&
|
|
|
465 !isDefaultMappingAsError((diag::kind)DiagID)))
|
|
|
466 return diag::Severity::Ignored;
|
|
|
467 }
|
|
|
468
|
|
|
469 // If -Werror is enabled, map warnings to errors unless explicitly disabled.
|
|
|
470 if (Result == diag::Severity::Warning) {
|
|
|
471 if (State->WarningsAsErrors && !Mapping.hasNoWarningAsError())
|
|
|
472 Result = diag::Severity::Error;
|
|
|
473 }
|
|
|
474
|
|
|
475 // If -Wfatal-errors is enabled, map errors to fatal unless explicitly
|
|
|
476 // disabled.
|
|
|
477 if (Result == diag::Severity::Error) {
|
|
|
478 if (State->ErrorsAsFatal && !Mapping.hasNoErrorAsFatal())
|
|
|
479 Result = diag::Severity::Fatal;
|
|
|
480 }
|
|
|
481
|
|
|
482 // If explicitly requested, map fatal errors to errors.
|
|
|
483 if (Result == diag::Severity::Fatal &&
|
|
|
484 Diag.CurDiagID != diag::fatal_too_many_errors && Diag.FatalsAsError)
|
|
|
485 Result = diag::Severity::Error;
|
|
|
486
|
|
|
487 // Custom diagnostics always are emitted in system headers.
|
|
|
488 bool ShowInSystemHeader =
|
|
|
489 !GetDiagInfo(DiagID) || GetDiagInfo(DiagID)->WarnShowInSystemHeader;
|
|
|
490
|
|
|
491 // If we are in a system header, we ignore it. We look at the diagnostic class
|
|
|
492 // because we also want to ignore extensions and warnings in -Werror and
|
|
|
493 // -pedantic-errors modes, which *map* warnings/extensions to errors.
|
|
|
494 if (State->SuppressSystemWarnings && !ShowInSystemHeader && Loc.isValid() &&
|
|
|
495 Diag.getSourceManager().isInSystemHeader(
|
|
|
496 Diag.getSourceManager().getExpansionLoc(Loc)))
|
|
|
497 return diag::Severity::Ignored;
|
|
|
498
|
|
|
499 return Result;
|
|
|
500 }
|
|
|
501
|
|
|
502 #define GET_DIAG_ARRAYS
|
|
|
503 #include "clang/Basic/DiagnosticGroups.inc"
|
|
|
504 #undef GET_DIAG_ARRAYS
|
|
|
505
|
|
|
506 namespace {
|
|
|
507 struct WarningOption {
|
|
|
508 uint16_t NameOffset;
|
|
|
509 uint16_t Members;
|
|
|
510 uint16_t SubGroups;
|
|
|
511
|
|
|
512 // String is stored with a pascal-style length byte.
|
|
|
513 StringRef getName() const {
|
|
|
514 return StringRef(DiagGroupNames + NameOffset + 1,
|
|
|
515 DiagGroupNames[NameOffset]);
|
|
|
516 }
|
|
|
517 };
|
|
|
518 }
|
|
|
519
|
|
|
520 // Second the table of options, sorted by name for fast binary lookup.
|
|
|
521 static const WarningOption OptionTable[] = {
|
|
|
522 #define GET_DIAG_TABLE
|
|
|
523 #include "clang/Basic/DiagnosticGroups.inc"
|
|
|
524 #undef GET_DIAG_TABLE
|
|
|
525 };
|
|
|
526
|
|
|
527 /// getWarningOptionForDiag - Return the lowest-level warning option that
|
|
|
528 /// enables the specified diagnostic. If there is no -Wfoo flag that controls
|
|
|
529 /// the diagnostic, this returns null.
|
|
|
530 StringRef DiagnosticIDs::getWarningOptionForDiag(unsigned DiagID) {
|
|
|
531 if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
|
|
|
532 return OptionTable[Info->getOptionGroupIndex()].getName();
|
|
|
533 return StringRef();
|
|
|
534 }
|
|
|
535
|
|
|
536 std::vector<std::string> DiagnosticIDs::getDiagnosticFlags() {
|
|
|
537 std::vector<std::string> Res;
|
|
|
538 for (size_t I = 1; DiagGroupNames[I] != '\0';) {
|
|
|
539 std::string Diag(DiagGroupNames + I + 1, DiagGroupNames[I]);
|
|
|
540 I += DiagGroupNames[I] + 1;
|
|
|
541 Res.push_back("-W" + Diag);
|
|
|
542 Res.push_back("-Wno-" + Diag);
|
|
|
543 }
|
|
|
544
|
|
|
545 return Res;
|
|
|
546 }
|
|
|
547
|
|
|
548 /// Return \c true if any diagnostics were found in this group, even if they
|
|
|
549 /// were filtered out due to having the wrong flavor.
|
|
|
550 static bool getDiagnosticsInGroup(diag::Flavor Flavor,
|
|
|
551 const WarningOption *Group,
|
|
|
552 SmallVectorImpl<diag::kind> &Diags) {
|
|
|
553 // An empty group is considered to be a warning group: we have empty groups
|
|
|
554 // for GCC compatibility, and GCC does not have remarks.
|
|
|
555 if (!Group->Members && !Group->SubGroups)
|
|
|
556 return Flavor == diag::Flavor::Remark;
|
|
|
557
|
|
|
558 bool NotFound = true;
|
|
|
559
|
|
|
560 // Add the members of the option diagnostic set.
|
|
|
561 const int16_t *Member = DiagArrays + Group->Members;
|
|
|
562 for (; *Member != -1; ++Member) {
|
|
|
563 if (GetDiagInfo(*Member)->getFlavor() == Flavor) {
|
|
|
564 NotFound = false;
|
|
|
565 Diags.push_back(*Member);
|
|
|
566 }
|
|
|
567 }
|
|
|
568
|
|
|
569 // Add the members of the subgroups.
|
|
|
570 const int16_t *SubGroups = DiagSubGroups + Group->SubGroups;
|
|
|
571 for (; *SubGroups != (int16_t)-1; ++SubGroups)
|
|
|
572 NotFound &= getDiagnosticsInGroup(Flavor, &OptionTable[(short)*SubGroups],
|
|
|
573 Diags);
|
|
|
574
|
|
|
575 return NotFound;
|
|
|
576 }
|
|
|
577
|
|
|
578 bool
|
|
|
579 DiagnosticIDs::getDiagnosticsInGroup(diag::Flavor Flavor, StringRef Group,
|
|
|
580 SmallVectorImpl<diag::kind> &Diags) const {
|
|
|
581 auto Found = llvm::partition_point(
|
|
|
582 OptionTable, [=](const WarningOption &O) { return O.getName() < Group; });
|
|
|
583 if (Found == std::end(OptionTable) || Found->getName() != Group)
|
|
|
584 return true; // Option not found.
|
|
|
585
|
|
|
586 return ::getDiagnosticsInGroup(Flavor, Found, Diags);
|
|
|
587 }
|
|
|
588
|
|
|
589 void DiagnosticIDs::getAllDiagnostics(diag::Flavor Flavor,
|
|
|
590 std::vector<diag::kind> &Diags) {
|
|
|
591 for (unsigned i = 0; i != StaticDiagInfoSize; ++i)
|
|
|
592 if (StaticDiagInfo[i].getFlavor() == Flavor)
|
|
|
593 Diags.push_back(StaticDiagInfo[i].DiagID);
|
|
|
594 }
|
|
|
595
|
|
|
596 StringRef DiagnosticIDs::getNearestOption(diag::Flavor Flavor,
|
|
|
597 StringRef Group) {
|
|
|
598 StringRef Best;
|
|
|
599 unsigned BestDistance = Group.size() + 1; // Sanity threshold.
|
|
|
600 for (const WarningOption &O : OptionTable) {
|
|
|
601 // Don't suggest ignored warning flags.
|
|
|
602 if (!O.Members && !O.SubGroups)
|
|
|
603 continue;
|
|
|
604
|
|
|
605 unsigned Distance = O.getName().edit_distance(Group, true, BestDistance);
|
|
|
606 if (Distance > BestDistance)
|
|
|
607 continue;
|
|
|
608
|
|
|
609 // Don't suggest groups that are not of this kind.
|
|
|
610 llvm::SmallVector<diag::kind, 8> Diags;
|
|
|
611 if (::getDiagnosticsInGroup(Flavor, &O, Diags) || Diags.empty())
|
|
|
612 continue;
|
|
|
613
|
|
|
614 if (Distance == BestDistance) {
|
|
|
615 // Two matches with the same distance, don't prefer one over the other.
|
|
|
616 Best = "";
|
|
|
617 } else if (Distance < BestDistance) {
|
|
|
618 // This is a better match.
|
|
|
619 Best = O.getName();
|
|
|
620 BestDistance = Distance;
|
|
|
621 }
|
|
|
622 }
|
|
|
623
|
|
|
624 return Best;
|
|
|
625 }
|
|
|
626
|
|
|
627 /// ProcessDiag - This is the method used to report a diagnostic that is
|
|
|
628 /// finally fully formed.
|
|
|
629 bool DiagnosticIDs::ProcessDiag(DiagnosticsEngine &Diag) const {
|
|
|
630 Diagnostic Info(&Diag);
|
|
|
631
|
|
|
632 assert(Diag.getClient() && "DiagnosticClient not set!");
|
|
|
633
|
|
|
634 // Figure out the diagnostic level of this message.
|
|
|
635 unsigned DiagID = Info.getID();
|
|
|
636 DiagnosticIDs::Level DiagLevel
|
|
|
637 = getDiagnosticLevel(DiagID, Info.getLocation(), Diag);
|
|
|
638
|
|
|
639 // Update counts for DiagnosticErrorTrap even if a fatal error occurred
|
|
|
640 // or diagnostics are suppressed.
|
|
|
641 if (DiagLevel >= DiagnosticIDs::Error) {
|
|
|
642 ++Diag.TrapNumErrorsOccurred;
|
|
|
643 if (isUnrecoverable(DiagID))
|
|
|
644 ++Diag.TrapNumUnrecoverableErrorsOccurred;
|
|
|
645 }
|
|
|
646
|
|
|
647 if (Diag.SuppressAllDiagnostics)
|
|
|
648 return false;
|
|
|
649
|
|
|
650 if (DiagLevel != DiagnosticIDs::Note) {
|
|
|
651 // Record that a fatal error occurred only when we see a second
|
|
|
652 // non-note diagnostic. This allows notes to be attached to the
|
|
|
653 // fatal error, but suppresses any diagnostics that follow those
|
|
|
654 // notes.
|
|
|
655 if (Diag.LastDiagLevel == DiagnosticIDs::Fatal)
|
|
|
656 Diag.FatalErrorOccurred = true;
|
|
|
657
|
|
|
658 Diag.LastDiagLevel = DiagLevel;
|
|
|
659 }
|
|
|
660
|
|
|
661 // If a fatal error has already been emitted, silence all subsequent
|
|
|
662 // diagnostics.
|
|
|
663 if (Diag.FatalErrorOccurred) {
|
|
|
664 if (DiagLevel >= DiagnosticIDs::Error &&
|
|
|
665 Diag.Client->IncludeInDiagnosticCounts()) {
|
|
|
666 ++Diag.NumErrors;
|
|
|
667 }
|
|
|
668
|
|
|
669 return false;
|
|
|
670 }
|
|
|
671
|
|
|
672 // If the client doesn't care about this message, don't issue it. If this is
|
|
|
673 // a note and the last real diagnostic was ignored, ignore it too.
|
|
|
674 if (DiagLevel == DiagnosticIDs::Ignored ||
|
|
|
675 (DiagLevel == DiagnosticIDs::Note &&
|
|
|
676 Diag.LastDiagLevel == DiagnosticIDs::Ignored))
|
|
|
677 return false;
|
|
|
678
|
|
|
679 if (DiagLevel >= DiagnosticIDs::Error) {
|
|
|
680 if (isUnrecoverable(DiagID))
|
|
|
681 Diag.UnrecoverableErrorOccurred = true;
|
|
|
682
|
|
|
683 // Warnings which have been upgraded to errors do not prevent compilation.
|
|
|
684 if (isDefaultMappingAsError(DiagID))
|
|
|
685 Diag.UncompilableErrorOccurred = true;
|
|
|
686
|
|
|
687 Diag.ErrorOccurred = true;
|
|
|
688 if (Diag.Client->IncludeInDiagnosticCounts()) {
|
|
|
689 ++Diag.NumErrors;
|
|
|
690 }
|
|
|
691
|
|
|
692 // If we've emitted a lot of errors, emit a fatal error instead of it to
|
|
|
693 // stop a flood of bogus errors.
|
|
|
694 if (Diag.ErrorLimit && Diag.NumErrors > Diag.ErrorLimit &&
|
|
|
695 DiagLevel == DiagnosticIDs::Error) {
|
|
|
696 Diag.SetDelayedDiagnostic(diag::fatal_too_many_errors);
|
|
|
697 return false;
|
|
|
698 }
|
|
|
699 }
|
|
|
700
|
|
|
701 // Make sure we set FatalErrorOccurred to ensure that the notes from the
|
|
|
702 // diagnostic that caused `fatal_too_many_errors` won't be emitted.
|
|
|
703 if (Diag.CurDiagID == diag::fatal_too_many_errors)
|
|
|
704 Diag.FatalErrorOccurred = true;
|
|
|
705 // Finally, report it.
|
|
|
706 EmitDiag(Diag, DiagLevel);
|
|
|
707 return true;
|
|
|
708 }
|
|
|
709
|
|
|
710 void DiagnosticIDs::EmitDiag(DiagnosticsEngine &Diag, Level DiagLevel) const {
|
|
|
711 Diagnostic Info(&Diag);
|
|
|
712 assert(DiagLevel != DiagnosticIDs::Ignored && "Cannot emit ignored diagnostics!");
|
|
|
713
|
|
|
714 Diag.Client->HandleDiagnostic((DiagnosticsEngine::Level)DiagLevel, Info);
|
|
|
715 if (Diag.Client->IncludeInDiagnosticCounts()) {
|
|
|
716 if (DiagLevel == DiagnosticIDs::Warning)
|
|
|
717 ++Diag.NumWarnings;
|
|
|
718 }
|
|
|
719
|
|
|
720 Diag.CurDiagID = ~0U;
|
|
|
721 }
|
|
|
722
|
|
|
723 bool DiagnosticIDs::isUnrecoverable(unsigned DiagID) const {
|
|
|
724 if (DiagID >= diag::DIAG_UPPER_LIMIT) {
|
|
|
725 assert(CustomDiagInfo && "Invalid CustomDiagInfo");
|
|
|
726 // Custom diagnostics.
|
|
|
727 return CustomDiagInfo->getLevel(DiagID) >= DiagnosticIDs::Error;
|
|
|
728 }
|
|
|
729
|
|
|
730 // Only errors may be unrecoverable.
|
|
|
731 if (getBuiltinDiagClass(DiagID) < CLASS_ERROR)
|
|
|
732 return false;
|
|
|
733
|
|
|
734 if (DiagID == diag::err_unavailable ||
|
|
|
735 DiagID == diag::err_unavailable_message)
|
|
|
736 return false;
|
|
|
737
|
|
|
738 // Currently we consider all ARC errors as recoverable.
|
|
|
739 if (isARCDiagnostic(DiagID))
|
|
|
740 return false;
|
|
|
741
|
|
|
742 return true;
|
|
|
743 }
|
|
|
744
|
|
|
745 bool DiagnosticIDs::isARCDiagnostic(unsigned DiagID) {
|
|
|
746 unsigned cat = getCategoryNumberForDiag(DiagID);
|
|
|
747 return DiagnosticIDs::getCategoryNameFromID(cat).startswith("ARC ");
|
|
|
748 }
|
