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