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