contrib/llvm/tools/clang/lib/Basic/DiagnosticIDs.cpp

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