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