DiagnosticIDs.cpp revision 6948bc4bcbd92502d90b877780a3b746275efa5b 
1//===--- DiagnosticIDs.cpp - Diagnostic IDs Handling ----------------------===//
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//  This file implements the Diagnostic IDs-related interfaces.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/AST/ASTDiagnostic.h"
15#include "clang/Analysis/AnalysisDiagnostic.h"
16#include "clang/Basic/DiagnosticIDs.h"
17#include "clang/Basic/DiagnosticCategories.h"
18#include "clang/Basic/SourceManager.h"
19#include "clang/Driver/DriverDiagnostic.h"
20#include "clang/Frontend/FrontendDiagnostic.h"
21#include "clang/Lex/LexDiagnostic.h"
22#include "clang/Parse/ParseDiagnostic.h"
23#include "clang/Sema/SemaDiagnostic.h"
24
25#include <map>
26using namespace clang;
27
28//===----------------------------------------------------------------------===//
29// Builtin Diagnostic information
30//===----------------------------------------------------------------------===//
31
32namespace {
33
34// Diagnostic classes.
35enum {
36  CLASS_NOTE       = 0x01,
37  CLASS_WARNING    = 0x02,
38  CLASS_EXTENSION  = 0x03,
39  CLASS_ERROR      = 0x04
40};
41
42struct StaticDiagInfoRec {
43  unsigned short DiagID;
44  unsigned Mapping : 3;
45  unsigned Class : 3;
46  unsigned SFINAE : 1;
47  unsigned AccessControl : 1;
48  unsigned Category : 5;
49
50  uint8_t  NameLen;
51  uint8_t  OptionGroupLen;
52
53  uint16_t DescriptionLen;
54  uint16_t BriefExplanationLen;
55  uint16_t FullExplanationLen;
56
57  const char *NameStr;
58  const char *OptionGroupStr;
59
60  const char *DescriptionStr;
61  const char *BriefExplanationStr;
62  const char *FullExplanationStr;
63
64  StringRef getName() const {
65    return StringRef(NameStr, NameLen);
66  }
67  StringRef getOptionGroup() const {
68    return StringRef(OptionGroupStr, OptionGroupLen);
69  }
70
71  StringRef getDescription() const {
72    return StringRef(DescriptionStr, DescriptionLen);
73  }
74  StringRef getBriefExplanation() const {
75    return StringRef(BriefExplanationStr, BriefExplanationLen);
76  }
77  StringRef getFullExplanation() const {
78    return StringRef(FullExplanationStr, FullExplanationLen);
79  }
80
81  bool operator<(const StaticDiagInfoRec &RHS) const {
82    return DiagID < RHS.DiagID;
83  }
84};
85
86struct StaticDiagNameIndexRec {
87  const char *NameStr;
88  unsigned short DiagID;
89  uint8_t NameLen;
90
91  StringRef getName() const {
92    return StringRef(NameStr, NameLen);
93  }
94
95  bool operator<(const StaticDiagNameIndexRec &RHS) const {
96    return getName() < RHS.getName();
97  }
98
99  bool operator==(const StaticDiagNameIndexRec &RHS) const {
100    return getName() == RHS.getName();
101  }
102};
103
104template <size_t SizeOfStr, typename FieldType>
105class StringSizerHelper {
106  char FIELD_TOO_SMALL[SizeOfStr <= FieldType(~0U) ? 1 : -1];
107public:
108  enum { Size = SizeOfStr };
109};
110
111} // namespace anonymous
112
113#define STR_SIZE(str, fieldTy) StringSizerHelper<sizeof(str)-1, fieldTy>::Size
114
115static const StaticDiagInfoRec StaticDiagInfo[] = {
116#define DIAG(ENUM,CLASS,DEFAULT_MAPPING,DESC,GROUP,               \
117             SFINAE,ACCESS,CATEGORY,BRIEF,FULL)                   \
118  { diag::ENUM, DEFAULT_MAPPING, CLASS, SFINAE, ACCESS, CATEGORY, \
119    STR_SIZE(#ENUM, uint8_t), STR_SIZE(GROUP, uint8_t),           \
120    STR_SIZE(DESC, uint16_t), STR_SIZE(BRIEF, uint16_t),          \
121    STR_SIZE(FULL, uint16_t),                                     \
122    #ENUM, GROUP, DESC, BRIEF, FULL },
123#include "clang/Basic/DiagnosticCommonKinds.inc"
124#include "clang/Basic/DiagnosticDriverKinds.inc"
125#include "clang/Basic/DiagnosticFrontendKinds.inc"
126#include "clang/Basic/DiagnosticLexKinds.inc"
127#include "clang/Basic/DiagnosticParseKinds.inc"
128#include "clang/Basic/DiagnosticASTKinds.inc"
129#include "clang/Basic/DiagnosticSemaKinds.inc"
130#include "clang/Basic/DiagnosticAnalysisKinds.inc"
131#undef DIAG
132  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
133};
134
135static const unsigned StaticDiagInfoSize =
136  sizeof(StaticDiagInfo)/sizeof(StaticDiagInfo[0])-1;
137
138/// To be sorted before first use (since it's splitted among multiple files)
139static const StaticDiagNameIndexRec StaticDiagNameIndex[] = {
140#define DIAG_NAME_INDEX(ENUM) { #ENUM, diag::ENUM, STR_SIZE(#ENUM, uint8_t) },
141#include "clang/Basic/DiagnosticIndexName.inc"
142#undef DIAG_NAME_INDEX
143  { 0, 0, 0 }
144};
145
146static const unsigned StaticDiagNameIndexSize =
147  sizeof(StaticDiagNameIndex)/sizeof(StaticDiagNameIndex[0])-1;
148
149/// GetDiagInfo - Return the StaticDiagInfoRec entry for the specified DiagID,
150/// or null if the ID is invalid.
151static const StaticDiagInfoRec *GetDiagInfo(unsigned DiagID) {
152  // If assertions are enabled, verify that the StaticDiagInfo array is sorted.
153#ifndef NDEBUG
154  static bool IsFirst = true;
155  if (IsFirst) {
156    for (unsigned i = 1; i != StaticDiagInfoSize; ++i) {
157      assert(StaticDiagInfo[i-1].DiagID != StaticDiagInfo[i].DiagID &&
158             "Diag ID conflict, the enums at the start of clang::diag (in "
159             "DiagnosticIDs.h) probably need to be increased");
160
161      assert(StaticDiagInfo[i-1] < StaticDiagInfo[i] &&
162             "Improperly sorted diag info");
163    }
164    IsFirst = false;
165  }
166#endif
167
168  // Search the diagnostic table with a binary search.
169  StaticDiagInfoRec Find = { DiagID, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0,0,0 };
170
171  const StaticDiagInfoRec *Found =
172    std::lower_bound(StaticDiagInfo, StaticDiagInfo + StaticDiagInfoSize, Find);
173  if (Found == StaticDiagInfo + StaticDiagInfoSize ||
174      Found->DiagID != DiagID)
175    return 0;
176
177  return Found;
178}
179
180static unsigned GetDefaultDiagMapping(unsigned DiagID) {
181  if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
182    return Info->Mapping;
183  return diag::MAP_FATAL;
184}
185
186/// getWarningOptionForDiag - Return the lowest-level warning option that
187/// enables the specified diagnostic.  If there is no -Wfoo flag that controls
188/// the diagnostic, this returns null.
189StringRef DiagnosticIDs::getWarningOptionForDiag(unsigned DiagID) {
190  if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
191    return Info->getOptionGroup();
192  return StringRef();
193}
194
195/// getCategoryNumberForDiag - Return the category number that a specified
196/// DiagID belongs to, or 0 if no category.
197unsigned DiagnosticIDs::getCategoryNumberForDiag(unsigned DiagID) {
198  if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
199    return Info->Category;
200  return 0;
201}
202
203namespace {
204  // The diagnostic category names.
205  struct StaticDiagCategoryRec {
206    const char *NameStr;
207    uint8_t NameLen;
208
209    StringRef getName() const {
210      return StringRef(NameStr, NameLen);
211    }
212  };
213}
214
215static const StaticDiagCategoryRec CategoryNameTable[] = {
216#define GET_CATEGORY_TABLE
217#define CATEGORY(X, ENUM) { X, STR_SIZE(X, uint8_t) },
218#include "clang/Basic/DiagnosticGroups.inc"
219#undef GET_CATEGORY_TABLE
220  { 0, 0 }
221};
222
223/// getNumberOfCategories - Return the number of categories
224unsigned DiagnosticIDs::getNumberOfCategories() {
225  return sizeof(CategoryNameTable) / sizeof(CategoryNameTable[0])-1;
226}
227
228/// getCategoryNameFromID - Given a category ID, return the name of the
229/// category, an empty string if CategoryID is zero, or null if CategoryID is
230/// invalid.
231StringRef DiagnosticIDs::getCategoryNameFromID(unsigned CategoryID) {
232  if (CategoryID >= getNumberOfCategories())
233   return StringRef();
234  return CategoryNameTable[CategoryID].getName();
235}
236
237
238
239DiagnosticIDs::SFINAEResponse
240DiagnosticIDs::getDiagnosticSFINAEResponse(unsigned DiagID) {
241  if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID)) {
242    if (Info->AccessControl)
243      return SFINAE_AccessControl;
244
245    if (!Info->SFINAE)
246      return SFINAE_Report;
247
248    if (Info->Class == CLASS_ERROR)
249      return SFINAE_SubstitutionFailure;
250
251    // Suppress notes, warnings, and extensions;
252    return SFINAE_Suppress;
253  }
254
255  return SFINAE_Report;
256}
257
258/// getName - Given a diagnostic ID, return its name
259StringRef DiagnosticIDs::getName(unsigned DiagID) {
260  if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
261    return Info->getName();
262  return StringRef();
263}
264
265/// getIdFromName - Given a diagnostic name, return its ID, or 0
266unsigned DiagnosticIDs::getIdFromName(StringRef Name) {
267  const StaticDiagNameIndexRec *StaticDiagNameIndexEnd =
268    StaticDiagNameIndex + StaticDiagNameIndexSize;
269
270  if (Name.empty()) { return diag::DIAG_UPPER_LIMIT; }
271
272  StaticDiagNameIndexRec Find = { Name.data(), 0, Name.size() };
273
274  const StaticDiagNameIndexRec *Found =
275    std::lower_bound( StaticDiagNameIndex, StaticDiagNameIndexEnd, Find);
276  if (Found == StaticDiagNameIndexEnd ||
277      Found->getName() != Name)
278    return diag::DIAG_UPPER_LIMIT;
279
280  return Found->DiagID;
281}
282
283/// getBriefExplanation - Given a diagnostic ID, return a brief explanation
284/// of the issue
285StringRef DiagnosticIDs::getBriefExplanation(unsigned DiagID) {
286  if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
287    return Info->getBriefExplanation();
288  return StringRef();
289}
290
291/// getFullExplanation - Given a diagnostic ID, return a full explanation
292/// of the issue
293StringRef DiagnosticIDs::getFullExplanation(unsigned DiagID) {
294  if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
295    return Info->getFullExplanation();
296  return StringRef();
297}
298
299/// getBuiltinDiagClass - Return the class field of the diagnostic.
300///
301static unsigned getBuiltinDiagClass(unsigned DiagID) {
302  if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
303    return Info->Class;
304  return ~0U;
305}
306
307//===----------------------------------------------------------------------===//
308// diag_iterator
309//===----------------------------------------------------------------------===//
310
311llvm::StringRef DiagnosticIDs::diag_iterator::getDiagName() const {
312  return static_cast<const StaticDiagNameIndexRec*>(impl)->getName();
313}
314
315unsigned DiagnosticIDs::diag_iterator::getDiagID() const {
316  return static_cast<const StaticDiagNameIndexRec*>(impl)->DiagID;
317}
318
319DiagnosticIDs::diag_iterator &DiagnosticIDs::diag_iterator::operator++() {
320  const StaticDiagNameIndexRec* ptr =
321    static_cast<const StaticDiagNameIndexRec*>(impl);;
322  ++ptr;
323  impl = ptr;
324  return *this;
325}
326
327DiagnosticIDs::diag_iterator DiagnosticIDs::diags_begin() {
328  return DiagnosticIDs::diag_iterator(StaticDiagNameIndex);
329}
330
331DiagnosticIDs::diag_iterator DiagnosticIDs::diags_end() {
332  return DiagnosticIDs::diag_iterator(StaticDiagNameIndex +
333                                      StaticDiagNameIndexSize);
334}
335
336//===----------------------------------------------------------------------===//
337// Custom Diagnostic information
338//===----------------------------------------------------------------------===//
339
340namespace clang {
341  namespace diag {
342    class CustomDiagInfo {
343      typedef std::pair<DiagnosticIDs::Level, std::string> DiagDesc;
344      std::vector<DiagDesc> DiagInfo;
345      std::map<DiagDesc, unsigned> DiagIDs;
346    public:
347
348      /// getDescription - Return the description of the specified custom
349      /// diagnostic.
350      StringRef getDescription(unsigned DiagID) const {
351        assert(this && DiagID-DIAG_UPPER_LIMIT < DiagInfo.size() &&
352               "Invalid diagnosic ID");
353        return DiagInfo[DiagID-DIAG_UPPER_LIMIT].second;
354      }
355
356      /// getLevel - Return the level of the specified custom diagnostic.
357      DiagnosticIDs::Level getLevel(unsigned DiagID) const {
358        assert(this && DiagID-DIAG_UPPER_LIMIT < DiagInfo.size() &&
359               "Invalid diagnosic ID");
360        return DiagInfo[DiagID-DIAG_UPPER_LIMIT].first;
361      }
362
363      unsigned getOrCreateDiagID(DiagnosticIDs::Level L, StringRef Message,
364                                 DiagnosticIDs &Diags) {
365        DiagDesc D(L, Message);
366        // Check to see if it already exists.
367        std::map<DiagDesc, unsigned>::iterator I = DiagIDs.lower_bound(D);
368        if (I != DiagIDs.end() && I->first == D)
369          return I->second;
370
371        // If not, assign a new ID.
372        unsigned ID = DiagInfo.size()+DIAG_UPPER_LIMIT;
373        DiagIDs.insert(std::make_pair(D, ID));
374        DiagInfo.push_back(D);
375        return ID;
376      }
377    };
378
379  } // end diag namespace
380} // end clang namespace
381
382
383//===----------------------------------------------------------------------===//
384// Common Diagnostic implementation
385//===----------------------------------------------------------------------===//
386
387DiagnosticIDs::DiagnosticIDs() {
388  CustomDiagInfo = 0;
389}
390
391DiagnosticIDs::~DiagnosticIDs() {
392  delete CustomDiagInfo;
393}
394
395/// getCustomDiagID - Return an ID for a diagnostic with the specified message
396/// and level.  If this is the first request for this diagnosic, it is
397/// registered and created, otherwise the existing ID is returned.
398unsigned DiagnosticIDs::getCustomDiagID(Level L, StringRef Message) {
399  if (CustomDiagInfo == 0)
400    CustomDiagInfo = new diag::CustomDiagInfo();
401  return CustomDiagInfo->getOrCreateDiagID(L, Message, *this);
402}
403
404
405/// isBuiltinWarningOrExtension - Return true if the unmapped diagnostic
406/// level of the specified diagnostic ID is a Warning or Extension.
407/// This only works on builtin diagnostics, not custom ones, and is not legal to
408/// call on NOTEs.
409bool DiagnosticIDs::isBuiltinWarningOrExtension(unsigned DiagID) {
410  return DiagID < diag::DIAG_UPPER_LIMIT &&
411         getBuiltinDiagClass(DiagID) != CLASS_ERROR;
412}
413
414/// \brief Determine whether the given built-in diagnostic ID is a
415/// Note.
416bool DiagnosticIDs::isBuiltinNote(unsigned DiagID) {
417  return DiagID < diag::DIAG_UPPER_LIMIT &&
418    getBuiltinDiagClass(DiagID) == CLASS_NOTE;
419}
420
421/// isBuiltinExtensionDiag - Determine whether the given built-in diagnostic
422/// ID is for an extension of some sort.  This also returns EnabledByDefault,
423/// which is set to indicate whether the diagnostic is ignored by default (in
424/// which case -pedantic enables it) or treated as a warning/error by default.
425///
426bool DiagnosticIDs::isBuiltinExtensionDiag(unsigned DiagID,
427                                        bool &EnabledByDefault) {
428  if (DiagID >= diag::DIAG_UPPER_LIMIT ||
429      getBuiltinDiagClass(DiagID) != CLASS_EXTENSION)
430    return false;
431
432  EnabledByDefault = GetDefaultDiagMapping(DiagID) != diag::MAP_IGNORE;
433  return true;
434}
435
436/// getDescription - Given a diagnostic ID, return a description of the
437/// issue.
438StringRef DiagnosticIDs::getDescription(unsigned DiagID) const {
439  if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
440    return Info->getDescription();
441  return CustomDiagInfo->getDescription(DiagID);
442}
443
444/// getDiagnosticLevel - Based on the way the client configured the Diagnostic
445/// object, classify the specified diagnostic ID into a Level, consumable by
446/// the DiagnosticClient.
447DiagnosticIDs::Level
448DiagnosticIDs::getDiagnosticLevel(unsigned DiagID, SourceLocation Loc,
449                                  const Diagnostic &Diag,
450                                  diag::Mapping *mapping) const {
451  // Handle custom diagnostics, which cannot be mapped.
452  if (DiagID >= diag::DIAG_UPPER_LIMIT)
453    return CustomDiagInfo->getLevel(DiagID);
454
455  unsigned DiagClass = getBuiltinDiagClass(DiagID);
456  assert(DiagClass != CLASS_NOTE && "Cannot get diagnostic level of a note!");
457  return getDiagnosticLevel(DiagID, DiagClass, Loc, Diag, mapping);
458}
459
460/// \brief Based on the way the client configured the Diagnostic
461/// object, classify the specified diagnostic ID into a Level, consumable by
462/// the DiagnosticClient.
463///
464/// \param Loc The source location we are interested in finding out the
465/// diagnostic state. Can be null in order to query the latest state.
466DiagnosticIDs::Level
467DiagnosticIDs::getDiagnosticLevel(unsigned DiagID, unsigned DiagClass,
468                                  SourceLocation Loc,
469                                  const Diagnostic &Diag,
470                                  diag::Mapping *mapping) const {
471  // Specific non-error diagnostics may be mapped to various levels from ignored
472  // to error.  Errors can only be mapped to fatal.
473  DiagnosticIDs::Level Result = DiagnosticIDs::Fatal;
474
475  Diagnostic::DiagStatePointsTy::iterator
476    Pos = Diag.GetDiagStatePointForLoc(Loc);
477  Diagnostic::DiagState *State = Pos->State;
478
479  // Get the mapping information, if unset, compute it lazily.
480  unsigned MappingInfo = Diag.getDiagnosticMappingInfo((diag::kind)DiagID,
481                                                       State);
482  if (MappingInfo == 0) {
483    MappingInfo = GetDefaultDiagMapping(DiagID);
484    Diag.setDiagnosticMappingInternal(DiagID, MappingInfo, State, false, false);
485  }
486
487  if (mapping)
488    *mapping = (diag::Mapping) (MappingInfo & 7);
489
490  bool ShouldEmitInSystemHeader = false;
491
492  switch (MappingInfo & 7) {
493  default: assert(0 && "Unknown mapping!");
494  case diag::MAP_IGNORE:
495    // Ignore this, unless this is an extension diagnostic and we're mapping
496    // them onto warnings or errors.
497    if (!isBuiltinExtensionDiag(DiagID) ||  // Not an extension
498        Diag.ExtBehavior == Diagnostic::Ext_Ignore || // Ext ignored
499        (MappingInfo & 8) != 0)             // User explicitly mapped it.
500      return DiagnosticIDs::Ignored;
501    Result = DiagnosticIDs::Warning;
502    if (Diag.ExtBehavior == Diagnostic::Ext_Error) Result = DiagnosticIDs::Error;
503    if (Result == DiagnosticIDs::Error && Diag.ErrorsAsFatal)
504      Result = DiagnosticIDs::Fatal;
505    break;
506  case diag::MAP_ERROR:
507    Result = DiagnosticIDs::Error;
508    if (Diag.ErrorsAsFatal)
509      Result = DiagnosticIDs::Fatal;
510    break;
511  case diag::MAP_FATAL:
512    Result = DiagnosticIDs::Fatal;
513    break;
514  case diag::MAP_WARNING_SHOW_IN_SYSTEM_HEADER:
515    ShouldEmitInSystemHeader = true;
516    // continue as MAP_WARNING.
517  case diag::MAP_WARNING:
518    // If warnings are globally mapped to ignore or error, do it.
519    if (Diag.IgnoreAllWarnings)
520      return DiagnosticIDs::Ignored;
521
522    Result = DiagnosticIDs::Warning;
523
524    // If this is an extension diagnostic and we're in -pedantic-error mode, and
525    // if the user didn't explicitly map it, upgrade to an error.
526    if (Diag.ExtBehavior == Diagnostic::Ext_Error &&
527        (MappingInfo & 8) == 0 &&
528        isBuiltinExtensionDiag(DiagID))
529      Result = DiagnosticIDs::Error;
530
531    if (Diag.WarningsAsErrors)
532      Result = DiagnosticIDs::Error;
533    if (Result == DiagnosticIDs::Error && Diag.ErrorsAsFatal)
534      Result = DiagnosticIDs::Fatal;
535    break;
536
537  case diag::MAP_WARNING_NO_WERROR:
538    // Diagnostics specified with -Wno-error=foo should be set to warnings, but
539    // not be adjusted by -Werror or -pedantic-errors.
540    Result = DiagnosticIDs::Warning;
541
542    // If warnings are globally mapped to ignore or error, do it.
543    if (Diag.IgnoreAllWarnings)
544      return DiagnosticIDs::Ignored;
545
546    break;
547
548  case diag::MAP_ERROR_NO_WFATAL:
549    // Diagnostics specified as -Wno-fatal-error=foo should be errors, but
550    // unaffected by -Wfatal-errors.
551    Result = DiagnosticIDs::Error;
552    break;
553  }
554
555  // Okay, we're about to return this as a "diagnostic to emit" one last check:
556  // if this is any sort of extension warning, and if we're in an __extension__
557  // block, silence it.
558  if (Diag.AllExtensionsSilenced && isBuiltinExtensionDiag(DiagID))
559    return DiagnosticIDs::Ignored;
560
561  // If we are in a system header, we ignore it.
562  // We also want to ignore extensions and warnings in -Werror and
563  // -pedantic-errors modes, which *map* warnings/extensions to errors.
564  if (Result >= DiagnosticIDs::Warning &&
565      DiagClass != CLASS_ERROR &&
566      // Custom diagnostics always are emitted in system headers.
567      DiagID < diag::DIAG_UPPER_LIMIT &&
568      !ShouldEmitInSystemHeader &&
569      Diag.SuppressSystemWarnings &&
570      Loc.isValid() &&
571      Diag.getSourceManager().isInSystemHeader(
572          Diag.getSourceManager().getExpansionLoc(Loc)))
573    return DiagnosticIDs::Ignored;
574
575  return Result;
576}
577
578namespace {
579  struct WarningOption {
580    // Be safe with the size of 'NameLen' because we don't statically check if
581    // the size will fit in the field; the struct size won't decrease with a
582    // shorter type anyway.
583    size_t NameLen;
584    const char *NameStr;
585    const short *Members;
586    const short *SubGroups;
587
588    StringRef getName() const {
589      return StringRef(NameStr, NameLen);
590    }
591  };
592}
593
594#define GET_DIAG_ARRAYS
595#include "clang/Basic/DiagnosticGroups.inc"
596#undef GET_DIAG_ARRAYS
597
598// Second the table of options, sorted by name for fast binary lookup.
599static const WarningOption OptionTable[] = {
600#define GET_DIAG_TABLE
601#include "clang/Basic/DiagnosticGroups.inc"
602#undef GET_DIAG_TABLE
603};
604static const size_t OptionTableSize =
605sizeof(OptionTable) / sizeof(OptionTable[0]);
606
607static bool WarningOptionCompare(const WarningOption &LHS,
608                                 const WarningOption &RHS) {
609  return LHS.getName() < RHS.getName();
610}
611
612static void MapGroupMembers(const WarningOption *Group, diag::Mapping Mapping,
613                            SourceLocation Loc, Diagnostic &Diag) {
614  // Option exists, poke all the members of its diagnostic set.
615  if (const short *Member = Group->Members) {
616    for (; *Member != -1; ++Member)
617      Diag.setDiagnosticMapping(*Member, Mapping, Loc);
618  }
619
620  // Enable/disable all subgroups along with this one.
621  if (const short *SubGroups = Group->SubGroups) {
622    for (; *SubGroups != (short)-1; ++SubGroups)
623      MapGroupMembers(&OptionTable[(short)*SubGroups], Mapping, Loc, Diag);
624  }
625}
626
627/// setDiagnosticGroupMapping - Change an entire diagnostic group (e.g.
628/// "unknown-pragmas" to have the specified mapping.  This returns true and
629/// ignores the request if "Group" was unknown, false otherwise.
630bool DiagnosticIDs::setDiagnosticGroupMapping(StringRef Group,
631                                              diag::Mapping Map,
632                                              SourceLocation Loc,
633                                              Diagnostic &Diag) const {
634  assert((Loc.isValid() ||
635          Diag.DiagStatePoints.empty() ||
636          Diag.DiagStatePoints.back().Loc.isInvalid()) &&
637         "Loc should be invalid only when the mapping comes from command-line");
638  assert((Loc.isInvalid() || Diag.DiagStatePoints.empty() ||
639          Diag.DiagStatePoints.back().Loc.isInvalid() ||
640          !Diag.SourceMgr->isBeforeInTranslationUnit(Loc,
641                                            Diag.DiagStatePoints.back().Loc)) &&
642         "Source location of new mapping is before the previous one!");
643
644  WarningOption Key = { Group.size(), Group.data(), 0, 0 };
645  const WarningOption *Found =
646  std::lower_bound(OptionTable, OptionTable + OptionTableSize, Key,
647                   WarningOptionCompare);
648  if (Found == OptionTable + OptionTableSize ||
649      Found->getName() != Group)
650    return true;  // Option not found.
651
652  MapGroupMembers(Found, Map, Loc, Diag);
653  return false;
654}
655
656/// ProcessDiag - This is the method used to report a diagnostic that is
657/// finally fully formed.
658bool DiagnosticIDs::ProcessDiag(Diagnostic &Diag) const {
659  DiagnosticInfo Info(&Diag);
660
661  if (Diag.SuppressAllDiagnostics)
662    return false;
663
664  assert(Diag.getClient() && "DiagnosticClient not set!");
665
666  // Figure out the diagnostic level of this message.
667  DiagnosticIDs::Level DiagLevel;
668  unsigned DiagID = Info.getID();
669
670  if (DiagID >= diag::DIAG_UPPER_LIMIT) {
671    // Handle custom diagnostics, which cannot be mapped.
672    DiagLevel = CustomDiagInfo->getLevel(DiagID);
673  } else {
674    // Get the class of the diagnostic.  If this is a NOTE, map it onto whatever
675    // the diagnostic level was for the previous diagnostic so that it is
676    // filtered the same as the previous diagnostic.
677    unsigned DiagClass = getBuiltinDiagClass(DiagID);
678    if (DiagClass == CLASS_NOTE) {
679      DiagLevel = DiagnosticIDs::Note;
680    } else {
681      DiagLevel = getDiagnosticLevel(DiagID, DiagClass, Info.getLocation(),
682                                     Diag);
683    }
684  }
685
686  if (DiagLevel != DiagnosticIDs::Note) {
687    // Record that a fatal error occurred only when we see a second
688    // non-note diagnostic. This allows notes to be attached to the
689    // fatal error, but suppresses any diagnostics that follow those
690    // notes.
691    if (Diag.LastDiagLevel == DiagnosticIDs::Fatal)
692      Diag.FatalErrorOccurred = true;
693
694    Diag.LastDiagLevel = DiagLevel;
695  }
696
697  // Update counts for DiagnosticErrorTrap even if a fatal error occurred.
698  if (DiagLevel >= DiagnosticIDs::Error) {
699    ++Diag.TrapNumErrorsOccurred;
700    if (isUnrecoverable(DiagID))
701      ++Diag.TrapNumUnrecoverableErrorsOccurred;
702  }
703
704  // If a fatal error has already been emitted, silence all subsequent
705  // diagnostics.
706  if (Diag.FatalErrorOccurred) {
707    if (DiagLevel >= DiagnosticIDs::Error &&
708        Diag.Client->IncludeInDiagnosticCounts()) {
709      ++Diag.NumErrors;
710      ++Diag.NumErrorsSuppressed;
711    }
712
713    return false;
714  }
715
716  // If the client doesn't care about this message, don't issue it.  If this is
717  // a note and the last real diagnostic was ignored, ignore it too.
718  if (DiagLevel == DiagnosticIDs::Ignored ||
719      (DiagLevel == DiagnosticIDs::Note &&
720       Diag.LastDiagLevel == DiagnosticIDs::Ignored))
721    return false;
722
723  if (DiagLevel >= DiagnosticIDs::Error) {
724    if (isUnrecoverable(DiagID))
725      Diag.UnrecoverableErrorOccurred = true;
726
727    if (Diag.Client->IncludeInDiagnosticCounts()) {
728      Diag.ErrorOccurred = true;
729      ++Diag.NumErrors;
730    }
731
732    // If we've emitted a lot of errors, emit a fatal error after it to stop a
733    // flood of bogus errors.
734    if (Diag.ErrorLimit && Diag.NumErrors >= Diag.ErrorLimit &&
735        DiagLevel == DiagnosticIDs::Error)
736      Diag.SetDelayedDiagnostic(diag::fatal_too_many_errors);
737  }
738
739  // If we have any Fix-Its, make sure that all of the Fix-Its point into
740  // source locations that aren't macro expansions. If any point into macro
741  // expansions, remove all of the Fix-Its.
742  for (unsigned I = 0, N = Diag.NumFixItHints; I != N; ++I) {
743    const FixItHint &FixIt = Diag.FixItHints[I];
744    if (FixIt.RemoveRange.isInvalid() ||
745        FixIt.RemoveRange.getBegin().isMacroID() ||
746        FixIt.RemoveRange.getEnd().isMacroID()) {
747      Diag.NumFixItHints = 0;
748      break;
749    }
750  }
751
752  // Finally, report it.
753  Diag.Client->HandleDiagnostic((Diagnostic::Level)DiagLevel, Info);
754  if (Diag.Client->IncludeInDiagnosticCounts()) {
755    if (DiagLevel == DiagnosticIDs::Warning)
756      ++Diag.NumWarnings;
757  }
758
759  Diag.CurDiagID = ~0U;
760
761  return true;
762}
763
764bool DiagnosticIDs::isUnrecoverable(unsigned DiagID) const {
765  if (DiagID >= diag::DIAG_UPPER_LIMIT) {
766    // Custom diagnostics.
767    return CustomDiagInfo->getLevel(DiagID) >= DiagnosticIDs::Error;
768  }
769
770  // Only errors may be unrecoverable.
771  if (getBuiltinDiagClass(DiagID) < CLASS_ERROR)
772    return false;
773
774  if (DiagID == diag::err_unavailable ||
775      DiagID == diag::err_unavailable_message)
776    return false;
777
778  // Currently we consider all ARC errors as recoverable.
779  if (getCategoryNumberForDiag(DiagID) ==
780        diag::DiagCat_Automatic_Reference_Counting_Issue)
781    return false;
782
783  return true;
784}
785