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

   1 //===--- Diagnostic.cpp - C Language Family Diagnostic 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-related interfaces.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/AST/ASTDiagnostic.h"
  15 #include "clang/Analysis/AnalysisDiagnostic.h"
  16 #include "clang/Basic/Diagnostic.h"
  17 #include "clang/Basic/FileManager.h"
  18 #include "clang/Basic/IdentifierTable.h"
  19 #include "clang/Basic/PartialDiagnostic.h"
  20 #include "clang/Basic/SourceLocation.h"
  21 #include "clang/Basic/SourceManager.h"
  22 #include "clang/Driver/DriverDiagnostic.h"
  23 #include "clang/Frontend/FrontendDiagnostic.h"
  24 #include "clang/Lex/LexDiagnostic.h"
  25 #include "clang/Parse/ParseDiagnostic.h"
  26 #include "clang/Sema/SemaDiagnostic.h"
  27 #include "llvm/ADT/SmallVector.h"
  28 #include "llvm/ADT/StringExtras.h"
  29 #include "llvm/Support/MemoryBuffer.h"
  30 #include "llvm/Support/raw_ostream.h"
  31
  32 #include <vector>
  33 #include <map>
  34 #include <cstring>
  35 using namespace clang;
  36
  37 //===----------------------------------------------------------------------===//
  38 // Builtin Diagnostic information
  39 //===----------------------------------------------------------------------===//
  40
  41 namespace {
  42
  43 // Diagnostic classes.
  44 enum {
  45   CLASS_NOTE       = 0x01,
  46   CLASS_WARNING    = 0x02,
  47   CLASS_EXTENSION  = 0x03,
  48   CLASS_ERROR      = 0x04
  49 };
  50
  51 struct StaticDiagInfoRec {
  52   unsigned short DiagID;
  53   unsigned Mapping : 3;
  54   unsigned Class : 3;
  55   bool SFINAE : 1;
  56   unsigned Category : 5;
  57
  58   const char *Description;
  59   const char *OptionGroup;
  60
  61   bool operator<(const StaticDiagInfoRec &RHS) const {
  62     return DiagID < RHS.DiagID;
  63   }
  64 };
  65
  66 }
  67
  68 static const StaticDiagInfoRec StaticDiagInfo[] = {
  69 #define DIAG(ENUM,CLASS,DEFAULT_MAPPING,DESC,GROUP,SFINAE, CATEGORY)    \
  70   { diag::ENUM, DEFAULT_MAPPING, CLASS, SFINAE, CATEGORY, DESC, GROUP },
  71 #include "clang/Basic/DiagnosticCommonKinds.inc"
  72 #include "clang/Basic/DiagnosticDriverKinds.inc"
  73 #include "clang/Basic/DiagnosticFrontendKinds.inc"
  74 #include "clang/Basic/DiagnosticLexKinds.inc"
  75 #include "clang/Basic/DiagnosticParseKinds.inc"
  76 #include "clang/Basic/DiagnosticASTKinds.inc"
  77 #include "clang/Basic/DiagnosticSemaKinds.inc"
  78 #include "clang/Basic/DiagnosticAnalysisKinds.inc"
  79   { 0, 0, 0, 0, 0, 0, 0}
  80 };
  81 #undef DIAG
  82
  83 /// GetDiagInfo - Return the StaticDiagInfoRec entry for the specified DiagID,
  84 /// or null if the ID is invalid.
  85 static const StaticDiagInfoRec *GetDiagInfo(unsigned DiagID) {
  86   unsigned NumDiagEntries = sizeof(StaticDiagInfo)/sizeof(StaticDiagInfo[0])-1;
  87
  88   // If assertions are enabled, verify that the StaticDiagInfo array is sorted.
  89 #ifndef NDEBUG
  90   static bool IsFirst = true;
  91   if (IsFirst) {
  92     for (unsigned i = 1; i != NumDiagEntries; ++i) {
  93       assert(StaticDiagInfo[i-1].DiagID != StaticDiagInfo[i].DiagID &&
  94              "Diag ID conflict, the enums at the start of clang::diag (in "
  95              "Diagnostic.h) probably need to be increased");
  96
  97       assert(StaticDiagInfo[i-1] < StaticDiagInfo[i] &&
  98              "Improperly sorted diag info");
  99     }
 100     IsFirst = false;
 101   }
 102 #endif
 103
 104   // Search the diagnostic table with a binary search.
 105   StaticDiagInfoRec Find = { DiagID, 0, 0, 0, 0, 0, 0 };
 106
 107   const StaticDiagInfoRec *Found =
 108     std::lower_bound(StaticDiagInfo, StaticDiagInfo + NumDiagEntries, Find);
 109   if (Found == StaticDiagInfo + NumDiagEntries ||
 110       Found->DiagID != DiagID)
 111     return 0;
 112
 113   return Found;
 114 }
 115
 116 static unsigned GetDefaultDiagMapping(unsigned DiagID) {
 117   if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
 118     return Info->Mapping;
 119   return diag::MAP_FATAL;
 120 }
 121
 122 /// getWarningOptionForDiag - Return the lowest-level warning option that
 123 /// enables the specified diagnostic.  If there is no -Wfoo flag that controls
 124 /// the diagnostic, this returns null.
 125 const char *Diagnostic::getWarningOptionForDiag(unsigned DiagID) {
 126   if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
 127     return Info->OptionGroup;
 128   return 0;
 129 }
 130
 131 /// getWarningOptionForDiag - Return the category number that a specified
 132 /// DiagID belongs to, or 0 if no category.
 133 unsigned Diagnostic::getCategoryNumberForDiag(unsigned DiagID) {
 134   if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
 135     return Info->Category;
 136   return 0;
 137 }
 138
 139 /// getCategoryNameFromID - Given a category ID, return the name of the
 140 /// category, an empty string if CategoryID is zero, or null if CategoryID is
 141 /// invalid.
 142 const char *Diagnostic::getCategoryNameFromID(unsigned CategoryID) {
 143   // Second the table of options, sorted by name for fast binary lookup.
 144   static const char *CategoryNameTable[] = {
 145 #define GET_CATEGORY_TABLE
 146 #define CATEGORY(X) X,
 147 #include "clang/Basic/DiagnosticGroups.inc"
 148 #undef GET_CATEGORY_TABLE
 149     "<<END>>"
 150   };
 151   static const size_t CategoryNameTableSize =
 152     sizeof(CategoryNameTable) / sizeof(CategoryNameTable[0])-1;
 153
 154   if (CategoryID >= CategoryNameTableSize) return 0;
 155   return CategoryNameTable[CategoryID];
 156 }
 157
 158
 159
 160 Diagnostic::SFINAEResponse
 161 Diagnostic::getDiagnosticSFINAEResponse(unsigned DiagID) {
 162   if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID)) {
 163     if (!Info->SFINAE)
 164       return SFINAE_Report;
 165
 166     if (Info->Class == CLASS_ERROR)
 167       return SFINAE_SubstitutionFailure;
 168
 169     // Suppress notes, warnings, and extensions;
 170     return SFINAE_Suppress;
 171   }
 172
 173   return SFINAE_Report;
 174 }
 175
 176 /// getDiagClass - Return the class field of the diagnostic.
 177 ///
 178 static unsigned getBuiltinDiagClass(unsigned DiagID) {
 179   if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
 180     return Info->Class;
 181   return ~0U;
 182 }
 183
 184 //===----------------------------------------------------------------------===//
 185 // Custom Diagnostic information
 186 //===----------------------------------------------------------------------===//
 187
 188 namespace clang {
 189   namespace diag {
 190     class CustomDiagInfo {
 191       typedef std::pair<Diagnostic::Level, std::string> DiagDesc;
 192       std::vector<DiagDesc> DiagInfo;
 193       std::map<DiagDesc, unsigned> DiagIDs;
 194     public:
 195
 196       /// getDescription - Return the description of the specified custom
 197       /// diagnostic.
 198       const char *getDescription(unsigned DiagID) const {
 199         assert(this && DiagID-DIAG_UPPER_LIMIT < DiagInfo.size() &&
 200                "Invalid diagnosic ID");
 201         return DiagInfo[DiagID-DIAG_UPPER_LIMIT].second.c_str();
 202       }
 203
 204       /// getLevel - Return the level of the specified custom diagnostic.
 205       Diagnostic::Level getLevel(unsigned DiagID) const {
 206         assert(this && DiagID-DIAG_UPPER_LIMIT < DiagInfo.size() &&
 207                "Invalid diagnosic ID");
 208         return DiagInfo[DiagID-DIAG_UPPER_LIMIT].first;
 209       }
 210
 211       unsigned getOrCreateDiagID(Diagnostic::Level L, llvm::StringRef Message,
 212                                  Diagnostic &Diags) {
 213         DiagDesc D(L, Message);
 214         // Check to see if it already exists.
 215         std::map<DiagDesc, unsigned>::iterator I = DiagIDs.lower_bound(D);
 216         if (I != DiagIDs.end() && I->first == D)
 217           return I->second;
 218
 219         // If not, assign a new ID.
 220         unsigned ID = DiagInfo.size()+DIAG_UPPER_LIMIT;
 221         DiagIDs.insert(std::make_pair(D, ID));
 222         DiagInfo.push_back(D);
 223         return ID;
 224       }
 225     };
 226
 227   } // end diag namespace
 228 } // end clang namespace
 229
 230
 231 //===----------------------------------------------------------------------===//
 232 // Common Diagnostic implementation
 233 //===----------------------------------------------------------------------===//
 234
 235 static void DummyArgToStringFn(Diagnostic::ArgumentKind AK, intptr_t QT,
 236                                const char *Modifier, unsigned ML,
 237                                const char *Argument, unsigned ArgLen,
 238                                const Diagnostic::ArgumentValue *PrevArgs,
 239                                unsigned NumPrevArgs,
 240                                llvm::SmallVectorImpl<char> &Output,
 241                                void *Cookie) {
 242   const char *Str = "<can't format argument>";
 243   Output.append(Str, Str+strlen(Str));
 244 }
 245
 246
 247 Diagnostic::Diagnostic(DiagnosticClient *client) : Client(client) {
 248   ArgToStringFn = DummyArgToStringFn;
 249   ArgToStringCookie = 0;
 250
 251   AllExtensionsSilenced = 0;
 252   IgnoreAllWarnings = false;
 253   WarningsAsErrors = false;
 254   ErrorsAsFatal = false;
 255   SuppressSystemWarnings = false;
 256   SuppressAllDiagnostics = false;
 257   ShowOverloads = Ovl_All;
 258   ExtBehavior = Ext_Ignore;
 259
 260   ErrorLimit = 0;
 261   TemplateBacktraceLimit = 0;
 262   CustomDiagInfo = 0;
 263
 264   // Set all mappings to 'unset'.
 265   DiagMappingsStack.clear();
 266   DiagMappingsStack.push_back(DiagMappings());
 267
 268   Reset();
 269 }
 270
 271 Diagnostic::~Diagnostic() {
 272   delete CustomDiagInfo;
 273 }
 274
 275
 276 void Diagnostic::pushMappings() {
 277   // Avoids undefined behavior when the stack has to resize.
 278   DiagMappingsStack.reserve(DiagMappingsStack.size() + 1);
 279   DiagMappingsStack.push_back(DiagMappingsStack.back());
 280 }
 281
 282 bool Diagnostic::popMappings() {
 283   if (DiagMappingsStack.size() == 1)
 284     return false;
 285
 286   DiagMappingsStack.pop_back();
 287   return true;
 288 }
 289
 290 /// getCustomDiagID - Return an ID for a diagnostic with the specified message
 291 /// and level.  If this is the first request for this diagnosic, it is
 292 /// registered and created, otherwise the existing ID is returned.
 293 unsigned Diagnostic::getCustomDiagID(Level L, llvm::StringRef Message) {
 294   if (CustomDiagInfo == 0)
 295     CustomDiagInfo = new diag::CustomDiagInfo();
 296   return CustomDiagInfo->getOrCreateDiagID(L, Message, *this);
 297 }
 298
 299
 300 /// isBuiltinWarningOrExtension - Return true if the unmapped diagnostic
 301 /// level of the specified diagnostic ID is a Warning or Extension.
 302 /// This only works on builtin diagnostics, not custom ones, and is not legal to
 303 /// call on NOTEs.
 304 bool Diagnostic::isBuiltinWarningOrExtension(unsigned DiagID) {
 305   return DiagID < diag::DIAG_UPPER_LIMIT &&
 306          getBuiltinDiagClass(DiagID) != CLASS_ERROR;
 307 }
 308
 309 /// \brief Determine whether the given built-in diagnostic ID is a
 310 /// Note.
 311 bool Diagnostic::isBuiltinNote(unsigned DiagID) {
 312   return DiagID < diag::DIAG_UPPER_LIMIT &&
 313     getBuiltinDiagClass(DiagID) == CLASS_NOTE;
 314 }
 315
 316 /// isBuiltinExtensionDiag - Determine whether the given built-in diagnostic
 317 /// ID is for an extension of some sort.  This also returns EnabledByDefault,
 318 /// which is set to indicate whether the diagnostic is ignored by default (in
 319 /// which case -pedantic enables it) or treated as a warning/error by default.
 320 ///
 321 bool Diagnostic::isBuiltinExtensionDiag(unsigned DiagID,
 322                                         bool &EnabledByDefault) {
 323   if (DiagID >= diag::DIAG_UPPER_LIMIT ||
 324       getBuiltinDiagClass(DiagID) != CLASS_EXTENSION)
 325     return false;
 326
 327   EnabledByDefault = GetDefaultDiagMapping(DiagID) != diag::MAP_IGNORE;
 328   return true;
 329 }
 330
 331 void Diagnostic::Reset() {
 332   ErrorOccurred = false;
 333   FatalErrorOccurred = false;
 334
 335   NumWarnings = 0;
 336   NumErrors = 0;
 337   NumErrorsSuppressed = 0;
 338   CurDiagID = ~0U;
 339   LastDiagLevel = Ignored;
 340   DelayedDiagID = 0;
 341 }
 342
 343 /// getDescription - Given a diagnostic ID, return a description of the
 344 /// issue.
 345 const char *Diagnostic::getDescription(unsigned DiagID) const {
 346   if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
 347     return Info->Description;
 348   return CustomDiagInfo->getDescription(DiagID);
 349 }
 350
 351 void Diagnostic::SetDelayedDiagnostic(unsigned DiagID, llvm::StringRef Arg1,
 352                                       llvm::StringRef Arg2) {
 353   if (DelayedDiagID)
 354     return;
 355
 356   DelayedDiagID = DiagID;
 357   DelayedDiagArg1 = Arg1.str();
 358   DelayedDiagArg2 = Arg2.str();
 359 }
 360
 361 void Diagnostic::ReportDelayed() {
 362   Report(DelayedDiagID) << DelayedDiagArg1 << DelayedDiagArg2;
 363   DelayedDiagID = 0;
 364   DelayedDiagArg1.clear();
 365   DelayedDiagArg2.clear();
 366 }
 367
 368 /// getDiagnosticLevel - Based on the way the client configured the Diagnostic
 369 /// object, classify the specified diagnostic ID into a Level, consumable by
 370 /// the DiagnosticClient.
 371 Diagnostic::Level Diagnostic::getDiagnosticLevel(unsigned DiagID) const {
 372   // Handle custom diagnostics, which cannot be mapped.
 373   if (DiagID >= diag::DIAG_UPPER_LIMIT)
 374     return CustomDiagInfo->getLevel(DiagID);
 375
 376   unsigned DiagClass = getBuiltinDiagClass(DiagID);
 377   assert(DiagClass != CLASS_NOTE && "Cannot get diagnostic level of a note!");
 378   return getDiagnosticLevel(DiagID, DiagClass);
 379 }
 380
 381 /// getDiagnosticLevel - Based on the way the client configured the Diagnostic
 382 /// object, classify the specified diagnostic ID into a Level, consumable by
 383 /// the DiagnosticClient.
 384 Diagnostic::Level
 385 Diagnostic::getDiagnosticLevel(unsigned DiagID, unsigned DiagClass) const {
 386   // Specific non-error diagnostics may be mapped to various levels from ignored
 387   // to error.  Errors can only be mapped to fatal.
 388   Diagnostic::Level Result = Diagnostic::Fatal;
 389
 390   // Get the mapping information, if unset, compute it lazily.
 391   unsigned MappingInfo = getDiagnosticMappingInfo((diag::kind)DiagID);
 392   if (MappingInfo == 0) {
 393     MappingInfo = GetDefaultDiagMapping(DiagID);
 394     setDiagnosticMappingInternal(DiagID, MappingInfo, false);
 395   }
 396
 397   switch (MappingInfo & 7) {
 398   default: assert(0 && "Unknown mapping!");
 399   case diag::MAP_IGNORE:
 400     // Ignore this, unless this is an extension diagnostic and we're mapping
 401     // them onto warnings or errors.
 402     if (!isBuiltinExtensionDiag(DiagID) ||  // Not an extension
 403         ExtBehavior == Ext_Ignore ||        // Extensions ignored anyway
 404         (MappingInfo & 8) != 0)             // User explicitly mapped it.
 405       return Diagnostic::Ignored;
 406     Result = Diagnostic::Warning;
 407     if (ExtBehavior == Ext_Error) Result = Diagnostic::Error;
 408     if (Result == Diagnostic::Error && ErrorsAsFatal)
 409       Result = Diagnostic::Fatal;
 410     break;
 411   case diag::MAP_ERROR:
 412     Result = Diagnostic::Error;
 413     if (ErrorsAsFatal)
 414       Result = Diagnostic::Fatal;
 415     break;
 416   case diag::MAP_FATAL:
 417     Result = Diagnostic::Fatal;
 418     break;
 419   case diag::MAP_WARNING:
 420     // If warnings are globally mapped to ignore or error, do it.
 421     if (IgnoreAllWarnings)
 422       return Diagnostic::Ignored;
 423
 424     Result = Diagnostic::Warning;
 425
 426     // If this is an extension diagnostic and we're in -pedantic-error mode, and
 427     // if the user didn't explicitly map it, upgrade to an error.
 428     if (ExtBehavior == Ext_Error &&
 429         (MappingInfo & 8) == 0 &&
 430         isBuiltinExtensionDiag(DiagID))
 431       Result = Diagnostic::Error;
 432
 433     if (WarningsAsErrors)
 434       Result = Diagnostic::Error;
 435     if (Result == Diagnostic::Error && ErrorsAsFatal)
 436       Result = Diagnostic::Fatal;
 437     break;
 438
 439   case diag::MAP_WARNING_NO_WERROR:
 440     // Diagnostics specified with -Wno-error=foo should be set to warnings, but
 441     // not be adjusted by -Werror or -pedantic-errors.
 442     Result = Diagnostic::Warning;
 443
 444     // If warnings are globally mapped to ignore or error, do it.
 445     if (IgnoreAllWarnings)
 446       return Diagnostic::Ignored;
 447
 448     break;
 449
 450   case diag::MAP_ERROR_NO_WFATAL:
 451     // Diagnostics specified as -Wno-fatal-error=foo should be errors, but
 452     // unaffected by -Wfatal-errors.
 453     Result = Diagnostic::Error;
 454     break;
 455   }
 456
 457   // Okay, we're about to return this as a "diagnostic to emit" one last check:
 458   // if this is any sort of extension warning, and if we're in an __extension__
 459   // block, silence it.
 460   if (AllExtensionsSilenced && isBuiltinExtensionDiag(DiagID))
 461     return Diagnostic::Ignored;
 462
 463   return Result;
 464 }
 465
 466 struct WarningOption {
 467   const char  *Name;
 468   const short *Members;
 469   const short *SubGroups;
 470 };
 471
 472 #define GET_DIAG_ARRAYS
 473 #include "clang/Basic/DiagnosticGroups.inc"
 474 #undef GET_DIAG_ARRAYS
 475
 476 // Second the table of options, sorted by name for fast binary lookup.
 477 static const WarningOption OptionTable[] = {
 478 #define GET_DIAG_TABLE
 479 #include "clang/Basic/DiagnosticGroups.inc"
 480 #undef GET_DIAG_TABLE
 481 };
 482 static const size_t OptionTableSize =
 483 sizeof(OptionTable) / sizeof(OptionTable[0]);
 484
 485 static bool WarningOptionCompare(const WarningOption &LHS,
 486                                  const WarningOption &RHS) {
 487   return strcmp(LHS.Name, RHS.Name) < 0;
 488 }
 489
 490 static void MapGroupMembers(const WarningOption *Group, diag::Mapping Mapping,
 491                             Diagnostic &Diags) {
 492   // Option exists, poke all the members of its diagnostic set.
 493   if (const short *Member = Group->Members) {
 494     for (; *Member != -1; ++Member)
 495       Diags.setDiagnosticMapping(*Member, Mapping);
 496   }
 497
 498   // Enable/disable all subgroups along with this one.
 499   if (const short *SubGroups = Group->SubGroups) {
 500     for (; *SubGroups != (short)-1; ++SubGroups)
 501       MapGroupMembers(&OptionTable[(short)*SubGroups], Mapping, Diags);
 502   }
 503 }
 504
 505 /// setDiagnosticGroupMapping - Change an entire diagnostic group (e.g.
 506 /// "unknown-pragmas" to have the specified mapping.  This returns true and
 507 /// ignores the request if "Group" was unknown, false otherwise.
 508 bool Diagnostic::setDiagnosticGroupMapping(const char *Group,
 509                                            diag::Mapping Map) {
 510
 511   WarningOption Key = { Group, 0, 0 };
 512   const WarningOption *Found =
 513   std::lower_bound(OptionTable, OptionTable + OptionTableSize, Key,
 514                    WarningOptionCompare);
 515   if (Found == OptionTable + OptionTableSize ||
 516       strcmp(Found->Name, Group) != 0)
 517     return true;  // Option not found.
 518
 519   MapGroupMembers(Found, Map, *this);
 520   return false;
 521 }
 522
 523
 524 /// ProcessDiag - This is the method used to report a diagnostic that is
 525 /// finally fully formed.
 526 bool Diagnostic::ProcessDiag() {
 527   DiagnosticInfo Info(this);
 528
 529   if (SuppressAllDiagnostics)
 530     return false;
 531
 532   // Figure out the diagnostic level of this message.
 533   Diagnostic::Level DiagLevel;
 534   unsigned DiagID = Info.getID();
 535
 536   // ShouldEmitInSystemHeader - True if this diagnostic should be produced even
 537   // in a system header.
 538   bool ShouldEmitInSystemHeader;
 539
 540   if (DiagID >= diag::DIAG_UPPER_LIMIT) {
 541     // Handle custom diagnostics, which cannot be mapped.
 542     DiagLevel = CustomDiagInfo->getLevel(DiagID);
 543
 544     // Custom diagnostics always are emitted in system headers.
 545     ShouldEmitInSystemHeader = true;
 546   } else {
 547     // Get the class of the diagnostic.  If this is a NOTE, map it onto whatever
 548     // the diagnostic level was for the previous diagnostic so that it is
 549     // filtered the same as the previous diagnostic.
 550     unsigned DiagClass = getBuiltinDiagClass(DiagID);
 551     if (DiagClass == CLASS_NOTE) {
 552       DiagLevel = Diagnostic::Note;
 553       ShouldEmitInSystemHeader = false;  // extra consideration is needed
 554     } else {
 555       // If this is not an error and we are in a system header, we ignore it.
 556       // Check the original Diag ID here, because we also want to ignore
 557       // extensions and warnings in -Werror and -pedantic-errors modes, which
 558       // *map* warnings/extensions to errors.
 559       ShouldEmitInSystemHeader = DiagClass == CLASS_ERROR;
 560
 561       DiagLevel = getDiagnosticLevel(DiagID, DiagClass);
 562     }
 563   }
 564
 565   if (DiagLevel != Diagnostic::Note) {
 566     // Record that a fatal error occurred only when we see a second
 567     // non-note diagnostic. This allows notes to be attached to the
 568     // fatal error, but suppresses any diagnostics that follow those
 569     // notes.
 570     if (LastDiagLevel == Diagnostic::Fatal)
 571       FatalErrorOccurred = true;
 572
 573     LastDiagLevel = DiagLevel;
 574   }
 575
 576   // If a fatal error has already been emitted, silence all subsequent
 577   // diagnostics.
 578   if (FatalErrorOccurred) {
 579     if (DiagLevel >= Diagnostic::Error && Client->IncludeInDiagnosticCounts()) {
 580       ++NumErrors;
 581       ++NumErrorsSuppressed;
 582     }
 583
 584     return false;
 585   }
 586
 587   // If the client doesn't care about this message, don't issue it.  If this is
 588   // a note and the last real diagnostic was ignored, ignore it too.
 589   if (DiagLevel == Diagnostic::Ignored ||
 590       (DiagLevel == Diagnostic::Note && LastDiagLevel == Diagnostic::Ignored))
 591     return false;
 592
 593   // If this diagnostic is in a system header and is not a clang error, suppress
 594   // it.
 595   if (SuppressSystemWarnings && !ShouldEmitInSystemHeader &&
 596       Info.getLocation().isValid() &&
 597       Info.getLocation().getInstantiationLoc().isInSystemHeader() &&
 598       (DiagLevel != Diagnostic::Note || LastDiagLevel == Diagnostic::Ignored)) {
 599     LastDiagLevel = Diagnostic::Ignored;
 600     return false;
 601   }
 602
 603   if (DiagLevel >= Diagnostic::Error) {
 604     if (Client->IncludeInDiagnosticCounts()) {
 605       ErrorOccurred = true;
 606       ++NumErrors;
 607     }
 608
 609     // If we've emitted a lot of errors, emit a fatal error after it to stop a
 610     // flood of bogus errors.
 611     if (ErrorLimit && NumErrors >= ErrorLimit &&
 612         DiagLevel == Diagnostic::Error)
 613       SetDelayedDiagnostic(diag::fatal_too_many_errors);
 614   }
 615
 616   // Finally, report it.
 617   Client->HandleDiagnostic(DiagLevel, Info);
 618   if (Client->IncludeInDiagnosticCounts()) {
 619     if (DiagLevel == Diagnostic::Warning)
 620       ++NumWarnings;
 621   }
 622
 623   CurDiagID = ~0U;
 624
 625   return true;
 626 }
 627
 628 bool DiagnosticBuilder::Emit() {
 629   // If DiagObj is null, then its soul was stolen by the copy ctor
 630   // or the user called Emit().
 631   if (DiagObj == 0) return false;
 632
 633   // When emitting diagnostics, we set the final argument count into
 634   // the Diagnostic object.
 635   DiagObj->NumDiagArgs = NumArgs;
 636   DiagObj->NumDiagRanges = NumRanges;
 637   DiagObj->NumFixItHints = NumFixItHints;
 638
 639   // Process the diagnostic, sending the accumulated information to the
 640   // DiagnosticClient.
 641   bool Emitted = DiagObj->ProcessDiag();
 642
 643   // Clear out the current diagnostic object.
 644   unsigned DiagID = DiagObj->CurDiagID;
 645   DiagObj->Clear();
 646
 647   // If there was a delayed diagnostic, emit it now.
 648   if (DiagObj->DelayedDiagID && DiagObj->DelayedDiagID != DiagID)
 649     DiagObj->ReportDelayed();
 650
 651   // This diagnostic is dead.
 652   DiagObj = 0;
 653
 654   return Emitted;
 655 }
 656
 657
 658 DiagnosticClient::~DiagnosticClient() {}
 659
 660
 661 /// ModifierIs - Return true if the specified modifier matches specified string.
 662 template <std::size_t StrLen>
 663 static bool ModifierIs(const char *Modifier, unsigned ModifierLen,
 664                        const char (&Str)[StrLen]) {
 665   return StrLen-1 == ModifierLen && !memcmp(Modifier, Str, StrLen-1);
 666 }
 667
 668 /// ScanForward - Scans forward, looking for the given character, skipping
 669 /// nested clauses and escaped characters.
 670 static const char *ScanFormat(const char *I, const char *E, char Target) {
 671   unsigned Depth = 0;
 672
 673   for ( ; I != E; ++I) {
 674     if (Depth == 0 && *I == Target) return I;
 675     if (Depth != 0 && *I == '}') Depth--;
 676
 677     if (*I == '%') {
 678       I++;
 679       if (I == E) break;
 680
 681       // Escaped characters get implicitly skipped here.
 682
 683       // Format specifier.
 684       if (!isdigit(*I) && !ispunct(*I)) {
 685         for (I++; I != E && !isdigit(*I) && *I != '{'; I++) ;
 686         if (I == E) break;
 687         if (*I == '{')
 688           Depth++;
 689       }
 690     }
 691   }
 692   return E;
 693 }
 694
 695 /// HandleSelectModifier - Handle the integer 'select' modifier.  This is used
 696 /// like this:  %select{foo|bar|baz}2.  This means that the integer argument
 697 /// "%2" has a value from 0-2.  If the value is 0, the diagnostic prints 'foo'.
 698 /// If the value is 1, it prints 'bar'.  If it has the value 2, it prints 'baz'.
 699 /// This is very useful for certain classes of variant diagnostics.
 700 static void HandleSelectModifier(const DiagnosticInfo &DInfo, unsigned ValNo,
 701                                  const char *Argument, unsigned ArgumentLen,
 702                                  llvm::SmallVectorImpl<char> &OutStr) {
 703   const char *ArgumentEnd = Argument+ArgumentLen;
 704
 705   // Skip over 'ValNo' |'s.
 706   while (ValNo) {
 707     const char *NextVal = ScanFormat(Argument, ArgumentEnd, '|');
 708     assert(NextVal != ArgumentEnd && "Value for integer select modifier was"
 709            " larger than the number of options in the diagnostic string!");
 710     Argument = NextVal+1;  // Skip this string.
 711     --ValNo;
 712   }
 713
 714   // Get the end of the value.  This is either the } or the |.
 715   const char *EndPtr = ScanFormat(Argument, ArgumentEnd, '|');
 716
 717   // Recursively format the result of the select clause into the output string.
 718   DInfo.FormatDiagnostic(Argument, EndPtr, OutStr);
 719 }
 720
 721 /// HandleIntegerSModifier - Handle the integer 's' modifier.  This adds the
 722 /// letter 's' to the string if the value is not 1.  This is used in cases like
 723 /// this:  "you idiot, you have %4 parameter%s4!".
 724 static void HandleIntegerSModifier(unsigned ValNo,
 725                                    llvm::SmallVectorImpl<char> &OutStr) {
 726   if (ValNo != 1)
 727     OutStr.push_back('s');
 728 }
 729
 730 /// HandleOrdinalModifier - Handle the integer 'ord' modifier.  This
 731 /// prints the ordinal form of the given integer, with 1 corresponding
 732 /// to the first ordinal.  Currently this is hard-coded to use the
 733 /// English form.
 734 static void HandleOrdinalModifier(unsigned ValNo,
 735                                   llvm::SmallVectorImpl<char> &OutStr) {
 736   assert(ValNo != 0 && "ValNo must be strictly positive!");
 737
 738   llvm::raw_svector_ostream Out(OutStr);
 739
 740   // We could use text forms for the first N ordinals, but the numeric
 741   // forms are actually nicer in diagnostics because they stand out.
 742   Out << ValNo;
 743
 744   // It is critically important that we do this perfectly for
 745   // user-written sequences with over 100 elements.
 746   switch (ValNo % 100) {
 747   case 11:
 748   case 12:
 749   case 13:
 750     Out << "th"; return;
 751   default:
 752     switch (ValNo % 10) {
 753     case 1: Out << "st"; return;
 754     case 2: Out << "nd"; return;
 755     case 3: Out << "rd"; return;
 756     default: Out << "th"; return;
 757     }
 758   }
 759 }
 760
 761
 762 /// PluralNumber - Parse an unsigned integer and advance Start.
 763 static unsigned PluralNumber(const char *&Start, const char *End) {
 764   // Programming 101: Parse a decimal number :-)
 765   unsigned Val = 0;
 766   while (Start != End && *Start >= '0' && *Start <= '9') {
 767     Val *= 10;
 768     Val += *Start - '0';
 769     ++Start;
 770   }
 771   return Val;
 772 }
 773
 774 /// TestPluralRange - Test if Val is in the parsed range. Modifies Start.
 775 static bool TestPluralRange(unsigned Val, const char *&Start, const char *End) {
 776   if (*Start != '[') {
 777     unsigned Ref = PluralNumber(Start, End);
 778     return Ref == Val;
 779   }
 780
 781   ++Start;
 782   unsigned Low = PluralNumber(Start, End);
 783   assert(*Start == ',' && "Bad plural expression syntax: expected ,");
 784   ++Start;
 785   unsigned High = PluralNumber(Start, End);
 786   assert(*Start == ']' && "Bad plural expression syntax: expected )");
 787   ++Start;
 788   return Low <= Val && Val <= High;
 789 }
 790
 791 /// EvalPluralExpr - Actual expression evaluator for HandlePluralModifier.
 792 static bool EvalPluralExpr(unsigned ValNo, const char *Start, const char *End) {
 793   // Empty condition?
 794   if (*Start == ':')
 795     return true;
 796
 797   while (1) {
 798     char C = *Start;
 799     if (C == '%') {
 800       // Modulo expression
 801       ++Start;
 802       unsigned Arg = PluralNumber(Start, End);
 803       assert(*Start == '=' && "Bad plural expression syntax: expected =");
 804       ++Start;
 805       unsigned ValMod = ValNo % Arg;
 806       if (TestPluralRange(ValMod, Start, End))
 807         return true;
 808     } else {
 809       assert((C == '[' || (C >= '0' && C <= '9')) &&
 810              "Bad plural expression syntax: unexpected character");
 811       // Range expression
 812       if (TestPluralRange(ValNo, Start, End))
 813         return true;
 814     }
 815
 816     // Scan for next or-expr part.
 817     Start = std::find(Start, End, ',');
 818     if (Start == End)
 819       break;
 820     ++Start;
 821   }
 822   return false;
 823 }
 824
 825 /// HandlePluralModifier - Handle the integer 'plural' modifier. This is used
 826 /// for complex plural forms, or in languages where all plurals are complex.
 827 /// The syntax is: %plural{cond1:form1|cond2:form2|:form3}, where condn are
 828 /// conditions that are tested in order, the form corresponding to the first
 829 /// that applies being emitted. The empty condition is always true, making the
 830 /// last form a default case.
 831 /// Conditions are simple boolean expressions, where n is the number argument.
 832 /// Here are the rules.
 833 /// condition  := expression | empty
 834 /// empty      :=                             -> always true
 835 /// expression := numeric [',' expression]    -> logical or
 836 /// numeric    := range                       -> true if n in range
 837 ///             | '%' number '=' range        -> true if n % number in range
 838 /// range      := number
 839 ///             | '[' number ',' number ']'   -> ranges are inclusive both ends
 840 ///
 841 /// Here are some examples from the GNU gettext manual written in this form:
 842 /// English:
 843 /// {1:form0|:form1}
 844 /// Latvian:
 845 /// {0:form2|%100=11,%10=0,%10=[2,9]:form1|:form0}
 846 /// Gaeilge:
 847 /// {1:form0|2:form1|:form2}
 848 /// Romanian:
 849 /// {1:form0|0,%100=[1,19]:form1|:form2}
 850 /// Lithuanian:
 851 /// {%10=0,%100=[10,19]:form2|%10=1:form0|:form1}
 852 /// Russian (requires repeated form):
 853 /// {%100=[11,14]:form2|%10=1:form0|%10=[2,4]:form1|:form2}
 854 /// Slovak
 855 /// {1:form0|[2,4]:form1|:form2}
 856 /// Polish (requires repeated form):
 857 /// {1:form0|%100=[10,20]:form2|%10=[2,4]:form1|:form2}
 858 static void HandlePluralModifier(unsigned ValNo,
 859                                  const char *Argument, unsigned ArgumentLen,
 860                                  llvm::SmallVectorImpl<char> &OutStr) {
 861   const char *ArgumentEnd = Argument + ArgumentLen;
 862   while (1) {
 863     assert(Argument < ArgumentEnd && "Plural expression didn't match.");
 864     const char *ExprEnd = Argument;
 865     while (*ExprEnd != ':') {
 866       assert(ExprEnd != ArgumentEnd && "Plural missing expression end");
 867       ++ExprEnd;
 868     }
 869     if (EvalPluralExpr(ValNo, Argument, ExprEnd)) {
 870       Argument = ExprEnd + 1;
 871       ExprEnd = ScanFormat(Argument, ArgumentEnd, '|');
 872       OutStr.append(Argument, ExprEnd);
 873       return;
 874     }
 875     Argument = ScanFormat(Argument, ArgumentEnd - 1, '|') + 1;
 876   }
 877 }
 878
 879
 880 /// FormatDiagnostic - Format this diagnostic into a string, substituting the
 881 /// formal arguments into the %0 slots.  The result is appended onto the Str
 882 /// array.
 883 void DiagnosticInfo::
 884 FormatDiagnostic(llvm::SmallVectorImpl<char> &OutStr) const {
 885   const char *DiagStr = getDiags()->getDescription(getID());
 886   const char *DiagEnd = DiagStr+strlen(DiagStr);
 887
 888   FormatDiagnostic(DiagStr, DiagEnd, OutStr);
 889 }
 890
 891 void DiagnosticInfo::
 892 FormatDiagnostic(const char *DiagStr, const char *DiagEnd,
 893                  llvm::SmallVectorImpl<char> &OutStr) const {
 894
 895   /// FormattedArgs - Keep track of all of the arguments formatted by
 896   /// ConvertArgToString and pass them into subsequent calls to
 897   /// ConvertArgToString, allowing the implementation to avoid redundancies in
 898   /// obvious cases.
 899   llvm::SmallVector<Diagnostic::ArgumentValue, 8> FormattedArgs;
 900
 901   while (DiagStr != DiagEnd) {
 902     if (DiagStr[0] != '%') {
 903       // Append non-%0 substrings to Str if we have one.
 904       const char *StrEnd = std::find(DiagStr, DiagEnd, '%');
 905       OutStr.append(DiagStr, StrEnd);
 906       DiagStr = StrEnd;
 907       continue;
 908     } else if (ispunct(DiagStr[1])) {
 909       OutStr.push_back(DiagStr[1]);  // %% -> %.
 910       DiagStr += 2;
 911       continue;
 912     }
 913
 914     // Skip the %.
 915     ++DiagStr;
 916
 917     // This must be a placeholder for a diagnostic argument.  The format for a
 918     // placeholder is one of "%0", "%modifier0", or "%modifier{arguments}0".
 919     // The digit is a number from 0-9 indicating which argument this comes from.
 920     // The modifier is a string of digits from the set [-a-z]+, arguments is a
 921     // brace enclosed string.
 922     const char *Modifier = 0, *Argument = 0;
 923     unsigned ModifierLen = 0, ArgumentLen = 0;
 924
 925     // Check to see if we have a modifier.  If so eat it.
 926     if (!isdigit(DiagStr[0])) {
 927       Modifier = DiagStr;
 928       while (DiagStr[0] == '-' ||
 929              (DiagStr[0] >= 'a' && DiagStr[0] <= 'z'))
 930         ++DiagStr;
 931       ModifierLen = DiagStr-Modifier;
 932
 933       // If we have an argument, get it next.
 934       if (DiagStr[0] == '{') {
 935         ++DiagStr; // Skip {.
 936         Argument = DiagStr;
 937
 938         DiagStr = ScanFormat(DiagStr, DiagEnd, '}');
 939         assert(DiagStr != DiagEnd && "Mismatched {}'s in diagnostic string!");
 940         ArgumentLen = DiagStr-Argument;
 941         ++DiagStr;  // Skip }.
 942       }
 943     }
 944
 945     assert(isdigit(*DiagStr) && "Invalid format for argument in diagnostic");
 946     unsigned ArgNo = *DiagStr++ - '0';
 947
 948     Diagnostic::ArgumentKind Kind = getArgKind(ArgNo);
 949
 950     switch (Kind) {
 951     // ---- STRINGS ----
 952     case Diagnostic::ak_std_string: {
 953       const std::string &S = getArgStdStr(ArgNo);
 954       assert(ModifierLen == 0 && "No modifiers for strings yet");
 955       OutStr.append(S.begin(), S.end());
 956       break;
 957     }
 958     case Diagnostic::ak_c_string: {
 959       const char *S = getArgCStr(ArgNo);
 960       assert(ModifierLen == 0 && "No modifiers for strings yet");
 961
 962       // Don't crash if get passed a null pointer by accident.
 963       if (!S)
 964         S = "(null)";
 965
 966       OutStr.append(S, S + strlen(S));
 967       break;
 968     }
 969     // ---- INTEGERS ----
 970     case Diagnostic::ak_sint: {
 971       int Val = getArgSInt(ArgNo);
 972
 973       if (ModifierIs(Modifier, ModifierLen, "select")) {
 974         HandleSelectModifier(*this, (unsigned)Val, Argument, ArgumentLen, OutStr);
 975       } else if (ModifierIs(Modifier, ModifierLen, "s")) {
 976         HandleIntegerSModifier(Val, OutStr);
 977       } else if (ModifierIs(Modifier, ModifierLen, "plural")) {
 978         HandlePluralModifier((unsigned)Val, Argument, ArgumentLen, OutStr);
 979       } else if (ModifierIs(Modifier, ModifierLen, "ordinal")) {
 980         HandleOrdinalModifier((unsigned)Val, OutStr);
 981       } else {
 982         assert(ModifierLen == 0 && "Unknown integer modifier");
 983         llvm::raw_svector_ostream(OutStr) << Val;
 984       }
 985       break;
 986     }
 987     case Diagnostic::ak_uint: {
 988       unsigned Val = getArgUInt(ArgNo);
 989
 990       if (ModifierIs(Modifier, ModifierLen, "select")) {
 991         HandleSelectModifier(*this, Val, Argument, ArgumentLen, OutStr);
 992       } else if (ModifierIs(Modifier, ModifierLen, "s")) {
 993         HandleIntegerSModifier(Val, OutStr);
 994       } else if (ModifierIs(Modifier, ModifierLen, "plural")) {
 995         HandlePluralModifier((unsigned)Val, Argument, ArgumentLen, OutStr);
 996       } else if (ModifierIs(Modifier, ModifierLen, "ordinal")) {
 997         HandleOrdinalModifier(Val, OutStr);
 998       } else {
 999         assert(ModifierLen == 0 && "Unknown integer modifier");
1000         llvm::raw_svector_ostream(OutStr) << Val;
1001       }
1002       break;
1003     }
1004     // ---- NAMES and TYPES ----
1005     case Diagnostic::ak_identifierinfo: {
1006       const IdentifierInfo *II = getArgIdentifier(ArgNo);
1007       assert(ModifierLen == 0 && "No modifiers for strings yet");
1008
1009       // Don't crash if get passed a null pointer by accident.
1010       if (!II) {
1011         const char *S = "(null)";
1012         OutStr.append(S, S + strlen(S));
1013         continue;
1014       }
1015
1016       llvm::raw_svector_ostream(OutStr) << '\'' << II->getName() << '\'';
1017       break;
1018     }
1019     case Diagnostic::ak_qualtype:
1020     case Diagnostic::ak_declarationname:
1021     case Diagnostic::ak_nameddecl:
1022     case Diagnostic::ak_nestednamespec:
1023     case Diagnostic::ak_declcontext:
1024       getDiags()->ConvertArgToString(Kind, getRawArg(ArgNo),
1025                                      Modifier, ModifierLen,
1026                                      Argument, ArgumentLen,
1027                                      FormattedArgs.data(), FormattedArgs.size(),
1028                                      OutStr);
1029       break;
1030     }
1031
1032     // Remember this argument info for subsequent formatting operations.  Turn
1033     // std::strings into a null terminated string to make it be the same case as
1034     // all the other ones.
1035     if (Kind != Diagnostic::ak_std_string)
1036       FormattedArgs.push_back(std::make_pair(Kind, getRawArg(ArgNo)));
1037     else
1038       FormattedArgs.push_back(std::make_pair(Diagnostic::ak_c_string,
1039                                         (intptr_t)getArgStdStr(ArgNo).c_str()));
1040
1041   }
1042 }
1043
1044 StoredDiagnostic::StoredDiagnostic() { }
1045
1046 StoredDiagnostic::StoredDiagnostic(Diagnostic::Level Level,
1047                                    llvm::StringRef Message)
1048   : Level(Level), Loc(), Message(Message) { }
1049
1050 StoredDiagnostic::StoredDiagnostic(Diagnostic::Level Level,
1051                                    const DiagnosticInfo &Info)
1052   : Level(Level), Loc(Info.getLocation()) {
1053   llvm::SmallString<64> Message;
1054   Info.FormatDiagnostic(Message);
1055   this->Message.assign(Message.begin(), Message.end());
1056
1057   Ranges.reserve(Info.getNumRanges());
1058   for (unsigned I = 0, N = Info.getNumRanges(); I != N; ++I)
1059     Ranges.push_back(Info.getRange(I));
1060
1061   FixIts.reserve(Info.getNumFixItHints());
1062   for (unsigned I = 0, N = Info.getNumFixItHints(); I != N; ++I)
1063     FixIts.push_back(Info.getFixItHint(I));
1064 }
1065
1066 StoredDiagnostic::~StoredDiagnostic() { }
1067
1068 static void WriteUnsigned(llvm::raw_ostream &OS, unsigned Value) {
1069   OS.write((const char *)&Value, sizeof(unsigned));
1070 }
1071
1072 static void WriteString(llvm::raw_ostream &OS, llvm::StringRef String) {
1073   WriteUnsigned(OS, String.size());
1074   OS.write(String.data(), String.size());
1075 }
1076
1077 static void WriteSourceLocation(llvm::raw_ostream &OS,
1078                                 SourceManager *SM,
1079                                 SourceLocation Location) {
1080   if (!SM || Location.isInvalid()) {
1081     // If we don't have a source manager or this location is invalid,
1082     // just write an invalid location.
1083     WriteUnsigned(OS, 0);
1084     WriteUnsigned(OS, 0);
1085     WriteUnsigned(OS, 0);
1086     return;
1087   }
1088
1089   Location = SM->getInstantiationLoc(Location);
1090   std::pair<FileID, unsigned> Decomposed = SM->getDecomposedLoc(Location);
1091
1092   const FileEntry *FE = SM->getFileEntryForID(Decomposed.first);
1093   if (FE)
1094     WriteString(OS, FE->getName());
1095   else {
1096     // Fallback to using the buffer name when there is no entry.
1097     WriteString(OS, SM->getBuffer(Decomposed.first)->getBufferIdentifier());
1098   }
1099
1100   WriteUnsigned(OS, SM->getLineNumber(Decomposed.first, Decomposed.second));
1101   WriteUnsigned(OS, SM->getColumnNumber(Decomposed.first, Decomposed.second));
1102 }
1103
1104 void StoredDiagnostic::Serialize(llvm::raw_ostream &OS) const {
1105   SourceManager *SM = 0;
1106   if (getLocation().isValid())
1107     SM = &const_cast<SourceManager &>(getLocation().getManager());
1108
1109   // Write a short header to help identify diagnostics.
1110   OS << (char)0x06 << (char)0x07;
1111
1112   // Write the diagnostic level and location.
1113   WriteUnsigned(OS, (unsigned)Level);
1114   WriteSourceLocation(OS, SM, getLocation());
1115
1116   // Write the diagnostic message.
1117   llvm::SmallString<64> Message;
1118   WriteString(OS, getMessage());
1119
1120   // Count the number of ranges that don't point into macros, since
1121   // only simple file ranges serialize well.
1122   unsigned NumNonMacroRanges = 0;
1123   for (range_iterator R = range_begin(), REnd = range_end(); R != REnd; ++R) {
1124     if (R->getBegin().isMacroID() || R->getEnd().isMacroID())
1125       continue;
1126
1127     ++NumNonMacroRanges;
1128   }
1129
1130   // Write the ranges.
1131   WriteUnsigned(OS, NumNonMacroRanges);
1132   if (NumNonMacroRanges) {
1133     for (range_iterator R = range_begin(), REnd = range_end(); R != REnd; ++R) {
1134       if (R->getBegin().isMacroID() || R->getEnd().isMacroID())
1135         continue;
1136
1137       WriteSourceLocation(OS, SM, R->getBegin());
1138       WriteSourceLocation(OS, SM, R->getEnd());
1139       WriteUnsigned(OS, R->isTokenRange());
1140     }
1141   }
1142
1143   // Determine if all of the fix-its involve rewrites with simple file
1144   // locations (not in macro instantiations). If so, we can write
1145   // fix-it information.
1146   unsigned NumFixIts = 0;
1147   for (fixit_iterator F = fixit_begin(), FEnd = fixit_end(); F != FEnd; ++F) {
1148     if (F->RemoveRange.isValid() &&
1149         (F->RemoveRange.getBegin().isMacroID() ||
1150          F->RemoveRange.getEnd().isMacroID())) {
1151       NumFixIts = 0;
1152       break;
1153     }
1154
1155     ++NumFixIts;
1156   }
1157
1158   // Write the fix-its.
1159   WriteUnsigned(OS, NumFixIts);
1160   for (fixit_iterator F = fixit_begin(), FEnd = fixit_end(); F != FEnd; ++F) {
1161     WriteSourceLocation(OS, SM, F->RemoveRange.getBegin());
1162     WriteSourceLocation(OS, SM, F->RemoveRange.getEnd());
1163     WriteUnsigned(OS, F->RemoveRange.isTokenRange());
1164     WriteString(OS, F->CodeToInsert);
1165   }
1166 }
1167
1168 static bool ReadUnsigned(const char *&Memory, const char *MemoryEnd,
1169                          unsigned &Value) {
1170   if (Memory + sizeof(unsigned) > MemoryEnd)
1171     return true;
1172
1173   memmove(&Value, Memory, sizeof(unsigned));
1174   Memory += sizeof(unsigned);
1175   return false;
1176 }
1177
1178 static bool ReadSourceLocation(FileManager &FM, SourceManager &SM,
1179                                const char *&Memory, const char *MemoryEnd,
1180                                SourceLocation &Location) {
1181   // Read the filename.
1182   unsigned FileNameLen = 0;
1183   if (ReadUnsigned(Memory, MemoryEnd, FileNameLen) ||
1184       Memory + FileNameLen > MemoryEnd)
1185     return true;
1186
1187   llvm::StringRef FileName(Memory, FileNameLen);
1188   Memory += FileNameLen;
1189
1190   // Read the line, column.
1191   unsigned Line = 0, Column = 0;
1192   if (ReadUnsigned(Memory, MemoryEnd, Line) ||
1193       ReadUnsigned(Memory, MemoryEnd, Column))
1194     return true;
1195
1196   if (FileName.empty()) {
1197     Location = SourceLocation();
1198     return false;
1199   }
1200
1201   const FileEntry *File = FM.getFile(FileName);
1202   if (!File)
1203     return true;
1204
1205   // Make sure that this file has an entry in the source manager.
1206   if (!SM.hasFileInfo(File))
1207     SM.createFileID(File, SourceLocation(), SrcMgr::C_User);
1208
1209   Location = SM.getLocation(File, Line, Column);
1210   return false;
1211 }
1212
1213 StoredDiagnostic
1214 StoredDiagnostic::Deserialize(FileManager &FM, SourceManager &SM,
1215                               const char *&Memory, const char *MemoryEnd) {
1216   while (true) {
1217     if (Memory == MemoryEnd)
1218       return StoredDiagnostic();
1219
1220     if (*Memory != 0x06) {
1221       ++Memory;
1222       continue;
1223     }
1224
1225     ++Memory;
1226     if (Memory == MemoryEnd)
1227       return StoredDiagnostic();
1228
1229     if (*Memory != 0x07) {
1230       ++Memory;
1231       continue;
1232     }
1233
1234     // We found the header. We're done.
1235     ++Memory;
1236     break;
1237   }
1238
1239   // Read the severity level.
1240   unsigned Level = 0;
1241   if (ReadUnsigned(Memory, MemoryEnd, Level) || Level > Diagnostic::Fatal)
1242     return StoredDiagnostic();
1243
1244   // Read the source location.
1245   SourceLocation Location;
1246   if (ReadSourceLocation(FM, SM, Memory, MemoryEnd, Location))
1247     return StoredDiagnostic();
1248
1249   // Read the diagnostic text.
1250   if (Memory == MemoryEnd)
1251     return StoredDiagnostic();
1252
1253   unsigned MessageLen = 0;
1254   if (ReadUnsigned(Memory, MemoryEnd, MessageLen) ||
1255       Memory + MessageLen > MemoryEnd)
1256     return StoredDiagnostic();
1257
1258   llvm::StringRef Message(Memory, MessageLen);
1259   Memory += MessageLen;
1260
1261
1262   // At this point, we have enough information to form a diagnostic. Do so.
1263   StoredDiagnostic Diag;
1264   Diag.Level = (Diagnostic::Level)Level;
1265   Diag.Loc = FullSourceLoc(Location, SM);
1266   Diag.Message = Message;
1267   if (Memory == MemoryEnd)
1268     return Diag;
1269
1270   // Read the source ranges.
1271   unsigned NumSourceRanges = 0;
1272   if (ReadUnsigned(Memory, MemoryEnd, NumSourceRanges))
1273     return Diag;
1274   for (unsigned I = 0; I != NumSourceRanges; ++I) {
1275     SourceLocation Begin, End;
1276     unsigned IsTokenRange;
1277     if (ReadSourceLocation(FM, SM, Memory, MemoryEnd, Begin) ||
1278         ReadSourceLocation(FM, SM, Memory, MemoryEnd, End) ||
1279         ReadUnsigned(Memory, MemoryEnd, IsTokenRange))
1280       return Diag;
1281
1282     Diag.Ranges.push_back(CharSourceRange(SourceRange(Begin, End),
1283                                           IsTokenRange));
1284   }
1285
1286   // Read the fix-it hints.
1287   unsigned NumFixIts = 0;
1288   if (ReadUnsigned(Memory, MemoryEnd, NumFixIts))
1289     return Diag;
1290   for (unsigned I = 0; I != NumFixIts; ++I) {
1291     SourceLocation RemoveBegin, RemoveEnd;
1292     unsigned InsertLen = 0, RemoveIsTokenRange;
1293     if (ReadSourceLocation(FM, SM, Memory, MemoryEnd, RemoveBegin) ||
1294         ReadSourceLocation(FM, SM, Memory, MemoryEnd, RemoveEnd) ||
1295         ReadUnsigned(Memory, MemoryEnd, RemoveIsTokenRange) ||
1296         ReadUnsigned(Memory, MemoryEnd, InsertLen) ||
1297         Memory + InsertLen > MemoryEnd) {
1298       Diag.FixIts.clear();
1299       return Diag;
1300     }
1301
1302     FixItHint Hint;
1303     Hint.RemoveRange = CharSourceRange(SourceRange(RemoveBegin, RemoveEnd),
1304                                        RemoveIsTokenRange);
1305     Hint.CodeToInsert.assign(Memory, Memory + InsertLen);
1306     Memory += InsertLen;
1307     Diag.FixIts.push_back(Hint);
1308   }
1309
1310   return Diag;
1311 }
1312
1313 /// IncludeInDiagnosticCounts - This method (whose default implementation
1314 ///  returns true) indicates whether the diagnostics handled by this
1315 ///  DiagnosticClient should be included in the number of diagnostics
1316 ///  reported by Diagnostic.
1317 bool DiagnosticClient::IncludeInDiagnosticCounts() const { return true; }
1318
1319 PartialDiagnostic::StorageAllocator::StorageAllocator() {
1320   for (unsigned I = 0; I != NumCached; ++I)
1321     FreeList[I] = Cached + I;
1322   NumFreeListEntries = NumCached;
1323 }
1324
1325 PartialDiagnostic::StorageAllocator::~StorageAllocator() {
1326   assert(NumFreeListEntries == NumCached && "A partial is on the lamb");
1327 }