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