1//===- Diagnostic.cpp - C Language Family Diagnostic Handling -------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9//  This file implements the Diagnostic-related interfaces.
10//
11//===----------------------------------------------------------------------===//
12
13#include "clang/Basic/Diagnostic.h"
14#include "clang/Basic/CharInfo.h"
15#include "clang/Basic/DiagnosticError.h"
16#include "clang/Basic/DiagnosticIDs.h"
17#include "clang/Basic/DiagnosticOptions.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/Basic/Specifiers.h"
23#include "clang/Basic/TokenKinds.h"
24#include "llvm/ADT/SmallString.h"
25#include "llvm/ADT/SmallVector.h"
26#include "llvm/ADT/StringExtras.h"
27#include "llvm/ADT/StringRef.h"
28#include "llvm/Support/CrashRecoveryContext.h"
29#include "llvm/Support/Locale.h"
30#include "llvm/Support/raw_ostream.h"
31#include <algorithm>
32#include <cassert>
33#include <cstddef>
34#include <cstdint>
35#include <cstring>
36#include <limits>
37#include <string>
38#include <utility>
39#include <vector>
40
41using namespace clang;
42
43const StreamingDiagnostic &clang::operator<<(const StreamingDiagnostic &DB,
44                                             DiagNullabilityKind nullability) {
45  StringRef string;
46  switch (nullability.first) {
47  case NullabilityKind::NonNull:
48    string = nullability.second ? "'nonnull'" : "'_Nonnull'";
49    break;
50
51  case NullabilityKind::Nullable:
52    string = nullability.second ? "'nullable'" : "'_Nullable'";
53    break;
54
55  case NullabilityKind::Unspecified:
56    string = nullability.second ? "'null_unspecified'" : "'_Null_unspecified'";
57    break;
58
59  case NullabilityKind::NullableResult:
60    assert(!nullability.second &&
61           "_Nullable_result isn't supported as context-sensitive keyword");
62    string = "_Nullable_result";
63    break;
64  }
65
66  DB.AddString(string);
67  return DB;
68}
69
70const StreamingDiagnostic &clang::operator<<(const StreamingDiagnostic &DB,
71                                             llvm::Error &&E) {
72  DB.AddString(toString(std::move(E)));
73  return DB;
74}
75
76static void DummyArgToStringFn(DiagnosticsEngine::ArgumentKind AK, intptr_t QT,
77                            StringRef Modifier, StringRef Argument,
78                            ArrayRef<DiagnosticsEngine::ArgumentValue> PrevArgs,
79                            SmallVectorImpl<char> &Output,
80                            void *Cookie,
81                            ArrayRef<intptr_t> QualTypeVals) {
82  StringRef Str = "<can't format argument>";
83  Output.append(Str.begin(), Str.end());
84}
85
86DiagnosticsEngine::DiagnosticsEngine(
87    IntrusiveRefCntPtr<DiagnosticIDs> diags,
88    IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, DiagnosticConsumer *client,
89    bool ShouldOwnClient)
90    : Diags(std::move(diags)), DiagOpts(std::move(DiagOpts)) {
91  setClient(client, ShouldOwnClient);
92  ArgToStringFn = DummyArgToStringFn;
93
94  Reset();
95}
96
97DiagnosticsEngine::~DiagnosticsEngine() {
98  // If we own the diagnostic client, destroy it first so that it can access the
99  // engine from its destructor.
100  setClient(nullptr);
101}
102
103void DiagnosticsEngine::dump() const {
104  DiagStatesByLoc.dump(*SourceMgr);
105}
106
107void DiagnosticsEngine::dump(StringRef DiagName) const {
108  DiagStatesByLoc.dump(*SourceMgr, DiagName);
109}
110
111void DiagnosticsEngine::setClient(DiagnosticConsumer *client,
112                                  bool ShouldOwnClient) {
113  Owner.reset(ShouldOwnClient ? client : nullptr);
114  Client = client;
115}
116
117void DiagnosticsEngine::pushMappings(SourceLocation Loc) {
118  DiagStateOnPushStack.push_back(GetCurDiagState());
119}
120
121bool DiagnosticsEngine::popMappings(SourceLocation Loc) {
122  if (DiagStateOnPushStack.empty())
123    return false;
124
125  if (DiagStateOnPushStack.back() != GetCurDiagState()) {
126    // State changed at some point between push/pop.
127    PushDiagStatePoint(DiagStateOnPushStack.back(), Loc);
128  }
129  DiagStateOnPushStack.pop_back();
130  return true;
131}
132
133void DiagnosticsEngine::Reset() {
134  ErrorOccurred = false;
135  UncompilableErrorOccurred = false;
136  FatalErrorOccurred = false;
137  UnrecoverableErrorOccurred = false;
138
139  NumWarnings = 0;
140  NumErrors = 0;
141  TrapNumErrorsOccurred = 0;
142  TrapNumUnrecoverableErrorsOccurred = 0;
143
144  CurDiagID = std::numeric_limits<unsigned>::max();
145  LastDiagLevel = DiagnosticIDs::Ignored;
146  DelayedDiagID = 0;
147
148  // Clear state related to #pragma diagnostic.
149  DiagStates.clear();
150  DiagStatesByLoc.clear();
151  DiagStateOnPushStack.clear();
152
153  // Create a DiagState and DiagStatePoint representing diagnostic changes
154  // through command-line.
155  DiagStates.emplace_back();
156  DiagStatesByLoc.appendFirst(&DiagStates.back());
157}
158
159void DiagnosticsEngine::SetDelayedDiagnostic(unsigned DiagID, StringRef Arg1,
160                                             StringRef Arg2, StringRef Arg3) {
161  if (DelayedDiagID)
162    return;
163
164  DelayedDiagID = DiagID;
165  DelayedDiagArg1 = Arg1.str();
166  DelayedDiagArg2 = Arg2.str();
167  DelayedDiagArg3 = Arg3.str();
168}
169
170void DiagnosticsEngine::ReportDelayed() {
171  unsigned ID = DelayedDiagID;
172  DelayedDiagID = 0;
173  Report(ID) << DelayedDiagArg1 << DelayedDiagArg2 << DelayedDiagArg3;
174}
175
176void DiagnosticsEngine::DiagStateMap::appendFirst(DiagState *State) {
177  assert(Files.empty() && "not first");
178  FirstDiagState = CurDiagState = State;
179  CurDiagStateLoc = SourceLocation();
180}
181
182void DiagnosticsEngine::DiagStateMap::append(SourceManager &SrcMgr,
183                                             SourceLocation Loc,
184                                             DiagState *State) {
185  CurDiagState = State;
186  CurDiagStateLoc = Loc;
187
188  std::pair<FileID, unsigned> Decomp = SrcMgr.getDecomposedLoc(Loc);
189  unsigned Offset = Decomp.second;
190  for (File *F = getFile(SrcMgr, Decomp.first); F;
191       Offset = F->ParentOffset, F = F->Parent) {
192    F->HasLocalTransitions = true;
193    auto &Last = F->StateTransitions.back();
194    assert(Last.Offset <= Offset && "state transitions added out of order");
195
196    if (Last.Offset == Offset) {
197      if (Last.State == State)
198        break;
199      Last.State = State;
200      continue;
201    }
202
203    F->StateTransitions.push_back({State, Offset});
204  }
205}
206
207DiagnosticsEngine::DiagState *
208DiagnosticsEngine::DiagStateMap::lookup(SourceManager &SrcMgr,
209                                        SourceLocation Loc) const {
210  // Common case: we have not seen any diagnostic pragmas.
211  if (Files.empty())
212    return FirstDiagState;
213
214  std::pair<FileID, unsigned> Decomp = SrcMgr.getDecomposedLoc(Loc);
215  const File *F = getFile(SrcMgr, Decomp.first);
216  return F->lookup(Decomp.second);
217}
218
219DiagnosticsEngine::DiagState *
220DiagnosticsEngine::DiagStateMap::File::lookup(unsigned Offset) const {
221  auto OnePastIt =
222      llvm::partition_point(StateTransitions, [=](const DiagStatePoint &P) {
223        return P.Offset <= Offset;
224      });
225  assert(OnePastIt != StateTransitions.begin() && "missing initial state");
226  return OnePastIt[-1].State;
227}
228
229DiagnosticsEngine::DiagStateMap::File *
230DiagnosticsEngine::DiagStateMap::getFile(SourceManager &SrcMgr,
231                                         FileID ID) const {
232  // Get or insert the File for this ID.
233  auto Range = Files.equal_range(ID);
234  if (Range.first != Range.second)
235    return &Range.first->second;
236  auto &F = Files.insert(Range.first, std::make_pair(ID, File()))->second;
237
238  // We created a new File; look up the diagnostic state at the start of it and
239  // initialize it.
240  if (ID.isValid()) {
241    std::pair<FileID, unsigned> Decomp = SrcMgr.getDecomposedIncludedLoc(ID);
242    F.Parent = getFile(SrcMgr, Decomp.first);
243    F.ParentOffset = Decomp.second;
244    F.StateTransitions.push_back({F.Parent->lookup(Decomp.second), 0});
245  } else {
246    // This is the (imaginary) root file into which we pretend all top-level
247    // files are included; it descends from the initial state.
248    //
249    // FIXME: This doesn't guarantee that we use the same ordering as
250    // isBeforeInTranslationUnit in the cases where someone invented another
251    // top-level file and added diagnostic pragmas to it. See the code at the
252    // end of isBeforeInTranslationUnit for the quirks it deals with.
253    F.StateTransitions.push_back({FirstDiagState, 0});
254  }
255  return &F;
256}
257
258void DiagnosticsEngine::DiagStateMap::dump(SourceManager &SrcMgr,
259                                           StringRef DiagName) const {
260  llvm::errs() << "diagnostic state at ";
261  CurDiagStateLoc.print(llvm::errs(), SrcMgr);
262  llvm::errs() << ": " << CurDiagState << "\n";
263
264  for (auto &F : Files) {
265    FileID ID = F.first;
266    File &File = F.second;
267
268    bool PrintedOuterHeading = false;
269    auto PrintOuterHeading = [&] {
270      if (PrintedOuterHeading) return;
271      PrintedOuterHeading = true;
272
273      llvm::errs() << "File " << &File << " <FileID " << ID.getHashValue()
274                   << ">: " << SrcMgr.getBufferOrFake(ID).getBufferIdentifier();
275
276      if (F.second.Parent) {
277        std::pair<FileID, unsigned> Decomp =
278            SrcMgr.getDecomposedIncludedLoc(ID);
279        assert(File.ParentOffset == Decomp.second);
280        llvm::errs() << " parent " << File.Parent << " <FileID "
281                     << Decomp.first.getHashValue() << "> ";
282        SrcMgr.getLocForStartOfFile(Decomp.first)
283              .getLocWithOffset(Decomp.second)
284              .print(llvm::errs(), SrcMgr);
285      }
286      if (File.HasLocalTransitions)
287        llvm::errs() << " has_local_transitions";
288      llvm::errs() << "\n";
289    };
290
291    if (DiagName.empty())
292      PrintOuterHeading();
293
294    for (DiagStatePoint &Transition : File.StateTransitions) {
295      bool PrintedInnerHeading = false;
296      auto PrintInnerHeading = [&] {
297        if (PrintedInnerHeading) return;
298        PrintedInnerHeading = true;
299
300        PrintOuterHeading();
301        llvm::errs() << "  ";
302        SrcMgr.getLocForStartOfFile(ID)
303              .getLocWithOffset(Transition.Offset)
304              .print(llvm::errs(), SrcMgr);
305        llvm::errs() << ": state " << Transition.State << ":\n";
306      };
307
308      if (DiagName.empty())
309        PrintInnerHeading();
310
311      for (auto &Mapping : *Transition.State) {
312        StringRef Option =
313            DiagnosticIDs::getWarningOptionForDiag(Mapping.first);
314        if (!DiagName.empty() && DiagName != Option)
315          continue;
316
317        PrintInnerHeading();
318        llvm::errs() << "    ";
319        if (Option.empty())
320          llvm::errs() << "<unknown " << Mapping.first << ">";
321        else
322          llvm::errs() << Option;
323        llvm::errs() << ": ";
324
325        switch (Mapping.second.getSeverity()) {
326        case diag::Severity::Ignored: llvm::errs() << "ignored"; break;
327        case diag::Severity::Remark: llvm::errs() << "remark"; break;
328        case diag::Severity::Warning: llvm::errs() << "warning"; break;
329        case diag::Severity::Error: llvm::errs() << "error"; break;
330        case diag::Severity::Fatal: llvm::errs() << "fatal"; break;
331        }
332
333        if (!Mapping.second.isUser())
334          llvm::errs() << " default";
335        if (Mapping.second.isPragma())
336          llvm::errs() << " pragma";
337        if (Mapping.second.hasNoWarningAsError())
338          llvm::errs() << " no-error";
339        if (Mapping.second.hasNoErrorAsFatal())
340          llvm::errs() << " no-fatal";
341        if (Mapping.second.wasUpgradedFromWarning())
342          llvm::errs() << " overruled";
343        llvm::errs() << "\n";
344      }
345    }
346  }
347}
348
349void DiagnosticsEngine::PushDiagStatePoint(DiagState *State,
350                                           SourceLocation Loc) {
351  assert(Loc.isValid() && "Adding invalid loc point");
352  DiagStatesByLoc.append(*SourceMgr, Loc, State);
353}
354
355void DiagnosticsEngine::setSeverity(diag::kind Diag, diag::Severity Map,
356                                    SourceLocation L) {
357  assert(Diag < diag::DIAG_UPPER_LIMIT &&
358         "Can only map builtin diagnostics");
359  assert((Diags->isBuiltinWarningOrExtension(Diag) ||
360          (Map == diag::Severity::Fatal || Map == diag::Severity::Error)) &&
361         "Cannot map errors into warnings!");
362  assert((L.isInvalid() || SourceMgr) && "No SourceMgr for valid location");
363
364  // Don't allow a mapping to a warning override an error/fatal mapping.
365  bool WasUpgradedFromWarning = false;
366  if (Map == diag::Severity::Warning) {
367    DiagnosticMapping &Info = GetCurDiagState()->getOrAddMapping(Diag);
368    if (Info.getSeverity() == diag::Severity::Error ||
369        Info.getSeverity() == diag::Severity::Fatal) {
370      Map = Info.getSeverity();
371      WasUpgradedFromWarning = true;
372    }
373  }
374  DiagnosticMapping Mapping = makeUserMapping(Map, L);
375  Mapping.setUpgradedFromWarning(WasUpgradedFromWarning);
376
377  // Common case; setting all the diagnostics of a group in one place.
378  if ((L.isInvalid() || L == DiagStatesByLoc.getCurDiagStateLoc()) &&
379      DiagStatesByLoc.getCurDiagState()) {
380    // FIXME: This is theoretically wrong: if the current state is shared with
381    // some other location (via push/pop) we will change the state for that
382    // other location as well. This cannot currently happen, as we can't update
383    // the diagnostic state at the same location at which we pop.
384    DiagStatesByLoc.getCurDiagState()->setMapping(Diag, Mapping);
385    return;
386  }
387
388  // A diagnostic pragma occurred, create a new DiagState initialized with
389  // the current one and a new DiagStatePoint to record at which location
390  // the new state became active.
391  DiagStates.push_back(*GetCurDiagState());
392  DiagStates.back().setMapping(Diag, Mapping);
393  PushDiagStatePoint(&DiagStates.back(), L);
394}
395
396bool DiagnosticsEngine::setSeverityForGroup(diag::Flavor Flavor,
397                                            StringRef Group, diag::Severity Map,
398                                            SourceLocation Loc) {
399  // Get the diagnostics in this group.
400  SmallVector<diag::kind, 256> GroupDiags;
401  if (Diags->getDiagnosticsInGroup(Flavor, Group, GroupDiags))
402    return true;
403
404  // Set the mapping.
405  for (diag::kind Diag : GroupDiags)
406    setSeverity(Diag, Map, Loc);
407
408  return false;
409}
410
411bool DiagnosticsEngine::setDiagnosticGroupWarningAsError(StringRef Group,
412                                                         bool Enabled) {
413  // If we are enabling this feature, just set the diagnostic mappings to map to
414  // errors.
415  if (Enabled)
416    return setSeverityForGroup(diag::Flavor::WarningOrError, Group,
417                               diag::Severity::Error);
418
419  // Otherwise, we want to set the diagnostic mapping's "no Werror" bit, and
420  // potentially downgrade anything already mapped to be a warning.
421
422  // Get the diagnostics in this group.
423  SmallVector<diag::kind, 8> GroupDiags;
424  if (Diags->getDiagnosticsInGroup(diag::Flavor::WarningOrError, Group,
425                                   GroupDiags))
426    return true;
427
428  // Perform the mapping change.
429  for (diag::kind Diag : GroupDiags) {
430    DiagnosticMapping &Info = GetCurDiagState()->getOrAddMapping(Diag);
431
432    if (Info.getSeverity() == diag::Severity::Error ||
433        Info.getSeverity() == diag::Severity::Fatal)
434      Info.setSeverity(diag::Severity::Warning);
435
436    Info.setNoWarningAsError(true);
437  }
438
439  return false;
440}
441
442bool DiagnosticsEngine::setDiagnosticGroupErrorAsFatal(StringRef Group,
443                                                       bool Enabled) {
444  // If we are enabling this feature, just set the diagnostic mappings to map to
445  // fatal errors.
446  if (Enabled)
447    return setSeverityForGroup(diag::Flavor::WarningOrError, Group,
448                               diag::Severity::Fatal);
449
450  // Otherwise, we want to set the diagnostic mapping's "no Wfatal-errors" bit,
451  // and potentially downgrade anything already mapped to be a fatal error.
452
453  // Get the diagnostics in this group.
454  SmallVector<diag::kind, 8> GroupDiags;
455  if (Diags->getDiagnosticsInGroup(diag::Flavor::WarningOrError, Group,
456                                   GroupDiags))
457    return true;
458
459  // Perform the mapping change.
460  for (diag::kind Diag : GroupDiags) {
461    DiagnosticMapping &Info = GetCurDiagState()->getOrAddMapping(Diag);
462
463    if (Info.getSeverity() == diag::Severity::Fatal)
464      Info.setSeverity(diag::Severity::Error);
465
466    Info.setNoErrorAsFatal(true);
467  }
468
469  return false;
470}
471
472void DiagnosticsEngine::setSeverityForAll(diag::Flavor Flavor,
473                                          diag::Severity Map,
474                                          SourceLocation Loc) {
475  // Get all the diagnostics.
476  std::vector<diag::kind> AllDiags;
477  DiagnosticIDs::getAllDiagnostics(Flavor, AllDiags);
478
479  // Set the mapping.
480  for (diag::kind Diag : AllDiags)
481    if (Diags->isBuiltinWarningOrExtension(Diag))
482      setSeverity(Diag, Map, Loc);
483}
484
485void DiagnosticsEngine::Report(const StoredDiagnostic &storedDiag) {
486  assert(CurDiagID == std::numeric_limits<unsigned>::max() &&
487         "Multiple diagnostics in flight at once!");
488
489  CurDiagLoc = storedDiag.getLocation();
490  CurDiagID = storedDiag.getID();
491  DiagStorage.NumDiagArgs = 0;
492
493  DiagStorage.DiagRanges.clear();
494  DiagStorage.DiagRanges.append(storedDiag.range_begin(),
495                                storedDiag.range_end());
496
497  DiagStorage.FixItHints.clear();
498  DiagStorage.FixItHints.append(storedDiag.fixit_begin(),
499                                storedDiag.fixit_end());
500
501  assert(Client && "DiagnosticConsumer not set!");
502  Level DiagLevel = storedDiag.getLevel();
503  Diagnostic Info(this, storedDiag.getMessage());
504  Client->HandleDiagnostic(DiagLevel, Info);
505  if (Client->IncludeInDiagnosticCounts()) {
506    if (DiagLevel == DiagnosticsEngine::Warning)
507      ++NumWarnings;
508  }
509
510  CurDiagID = std::numeric_limits<unsigned>::max();
511}
512
513bool DiagnosticsEngine::EmitCurrentDiagnostic(bool Force) {
514  assert(getClient() && "DiagnosticClient not set!");
515
516  bool Emitted;
517  if (Force) {
518    Diagnostic Info(this);
519
520    // Figure out the diagnostic level of this message.
521    DiagnosticIDs::Level DiagLevel
522      = Diags->getDiagnosticLevel(Info.getID(), Info.getLocation(), *this);
523
524    Emitted = (DiagLevel != DiagnosticIDs::Ignored);
525    if (Emitted) {
526      // Emit the diagnostic regardless of suppression level.
527      Diags->EmitDiag(*this, DiagLevel);
528    }
529  } else {
530    // Process the diagnostic, sending the accumulated information to the
531    // DiagnosticConsumer.
532    Emitted = ProcessDiag();
533  }
534
535  // Clear out the current diagnostic object.
536  Clear();
537
538  // If there was a delayed diagnostic, emit it now.
539  if (!Force && DelayedDiagID)
540    ReportDelayed();
541
542  return Emitted;
543}
544
545DiagnosticConsumer::~DiagnosticConsumer() = default;
546
547void DiagnosticConsumer::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
548                                        const Diagnostic &Info) {
549  if (!IncludeInDiagnosticCounts())
550    return;
551
552  if (DiagLevel == DiagnosticsEngine::Warning)
553    ++NumWarnings;
554  else if (DiagLevel >= DiagnosticsEngine::Error)
555    ++NumErrors;
556}
557
558/// ModifierIs - Return true if the specified modifier matches specified string.
559template <std::size_t StrLen>
560static bool ModifierIs(const char *Modifier, unsigned ModifierLen,
561                       const char (&Str)[StrLen]) {
562  return StrLen-1 == ModifierLen && memcmp(Modifier, Str, StrLen-1) == 0;
563}
564
565/// ScanForward - Scans forward, looking for the given character, skipping
566/// nested clauses and escaped characters.
567static const char *ScanFormat(const char *I, const char *E, char Target) {
568  unsigned Depth = 0;
569
570  for ( ; I != E; ++I) {
571    if (Depth == 0 && *I == Target) return I;
572    if (Depth != 0 && *I == '}') Depth--;
573
574    if (*I == '%') {
575      I++;
576      if (I == E) break;
577
578      // Escaped characters get implicitly skipped here.
579
580      // Format specifier.
581      if (!isDigit(*I) && !isPunctuation(*I)) {
582        for (I++; I != E && !isDigit(*I) && *I != '{'; I++) ;
583        if (I == E) break;
584        if (*I == '{')
585          Depth++;
586      }
587    }
588  }
589  return E;
590}
591
592/// HandleSelectModifier - Handle the integer 'select' modifier.  This is used
593/// like this:  %select{foo|bar|baz}2.  This means that the integer argument
594/// "%2" has a value from 0-2.  If the value is 0, the diagnostic prints 'foo'.
595/// If the value is 1, it prints 'bar'.  If it has the value 2, it prints 'baz'.
596/// This is very useful for certain classes of variant diagnostics.
597static void HandleSelectModifier(const Diagnostic &DInfo, unsigned ValNo,
598                                 const char *Argument, unsigned ArgumentLen,
599                                 SmallVectorImpl<char> &OutStr) {
600  const char *ArgumentEnd = Argument+ArgumentLen;
601
602  // Skip over 'ValNo' |'s.
603  while (ValNo) {
604    const char *NextVal = ScanFormat(Argument, ArgumentEnd, '|');
605    assert(NextVal != ArgumentEnd && "Value for integer select modifier was"
606           " larger than the number of options in the diagnostic string!");
607    Argument = NextVal+1;  // Skip this string.
608    --ValNo;
609  }
610
611  // Get the end of the value.  This is either the } or the |.
612  const char *EndPtr = ScanFormat(Argument, ArgumentEnd, '|');
613
614  // Recursively format the result of the select clause into the output string.
615  DInfo.FormatDiagnostic(Argument, EndPtr, OutStr);
616}
617
618/// HandleIntegerSModifier - Handle the integer 's' modifier.  This adds the
619/// letter 's' to the string if the value is not 1.  This is used in cases like
620/// this:  "you idiot, you have %4 parameter%s4!".
621static void HandleIntegerSModifier(unsigned ValNo,
622                                   SmallVectorImpl<char> &OutStr) {
623  if (ValNo != 1)
624    OutStr.push_back('s');
625}
626
627/// HandleOrdinalModifier - Handle the integer 'ord' modifier.  This
628/// prints the ordinal form of the given integer, with 1 corresponding
629/// to the first ordinal.  Currently this is hard-coded to use the
630/// English form.
631static void HandleOrdinalModifier(unsigned ValNo,
632                                  SmallVectorImpl<char> &OutStr) {
633  assert(ValNo != 0 && "ValNo must be strictly positive!");
634
635  llvm::raw_svector_ostream Out(OutStr);
636
637  // We could use text forms for the first N ordinals, but the numeric
638  // forms are actually nicer in diagnostics because they stand out.
639  Out << ValNo << llvm::getOrdinalSuffix(ValNo);
640}
641
642/// PluralNumber - Parse an unsigned integer and advance Start.
643static unsigned PluralNumber(const char *&Start, const char *End) {
644  // Programming 101: Parse a decimal number :-)
645  unsigned Val = 0;
646  while (Start != End && *Start >= '0' && *Start <= '9') {
647    Val *= 10;
648    Val += *Start - '0';
649    ++Start;
650  }
651  return Val;
652}
653
654/// TestPluralRange - Test if Val is in the parsed range. Modifies Start.
655static bool TestPluralRange(unsigned Val, const char *&Start, const char *End) {
656  if (*Start != '[') {
657    unsigned Ref = PluralNumber(Start, End);
658    return Ref == Val;
659  }
660
661  ++Start;
662  unsigned Low = PluralNumber(Start, End);
663  assert(*Start == ',' && "Bad plural expression syntax: expected ,");
664  ++Start;
665  unsigned High = PluralNumber(Start, End);
666  assert(*Start == ']' && "Bad plural expression syntax: expected )");
667  ++Start;
668  return Low <= Val && Val <= High;
669}
670
671/// EvalPluralExpr - Actual expression evaluator for HandlePluralModifier.
672static bool EvalPluralExpr(unsigned ValNo, const char *Start, const char *End) {
673  // Empty condition?
674  if (*Start == ':')
675    return true;
676
677  while (true) {
678    char C = *Start;
679    if (C == '%') {
680      // Modulo expression
681      ++Start;
682      unsigned Arg = PluralNumber(Start, End);
683      assert(*Start == '=' && "Bad plural expression syntax: expected =");
684      ++Start;
685      unsigned ValMod = ValNo % Arg;
686      if (TestPluralRange(ValMod, Start, End))
687        return true;
688    } else {
689      assert((C == '[' || (C >= '0' && C <= '9')) &&
690             "Bad plural expression syntax: unexpected character");
691      // Range expression
692      if (TestPluralRange(ValNo, Start, End))
693        return true;
694    }
695
696    // Scan for next or-expr part.
697    Start = std::find(Start, End, ',');
698    if (Start == End)
699      break;
700    ++Start;
701  }
702  return false;
703}
704
705/// HandlePluralModifier - Handle the integer 'plural' modifier. This is used
706/// for complex plural forms, or in languages where all plurals are complex.
707/// The syntax is: %plural{cond1:form1|cond2:form2|:form3}, where condn are
708/// conditions that are tested in order, the form corresponding to the first
709/// that applies being emitted. The empty condition is always true, making the
710/// last form a default case.
711/// Conditions are simple boolean expressions, where n is the number argument.
712/// Here are the rules.
713/// condition  := expression | empty
714/// empty      :=                             -> always true
715/// expression := numeric [',' expression]    -> logical or
716/// numeric    := range                       -> true if n in range
717///             | '%' number '=' range        -> true if n % number in range
718/// range      := number
719///             | '[' number ',' number ']'   -> ranges are inclusive both ends
720///
721/// Here are some examples from the GNU gettext manual written in this form:
722/// English:
723/// {1:form0|:form1}
724/// Latvian:
725/// {0:form2|%100=11,%10=0,%10=[2,9]:form1|:form0}
726/// Gaeilge:
727/// {1:form0|2:form1|:form2}
728/// Romanian:
729/// {1:form0|0,%100=[1,19]:form1|:form2}
730/// Lithuanian:
731/// {%10=0,%100=[10,19]:form2|%10=1:form0|:form1}
732/// Russian (requires repeated form):
733/// {%100=[11,14]:form2|%10=1:form0|%10=[2,4]:form1|:form2}
734/// Slovak
735/// {1:form0|[2,4]:form1|:form2}
736/// Polish (requires repeated form):
737/// {1:form0|%100=[10,20]:form2|%10=[2,4]:form1|:form2}
738static void HandlePluralModifier(const Diagnostic &DInfo, unsigned ValNo,
739                                 const char *Argument, unsigned ArgumentLen,
740                                 SmallVectorImpl<char> &OutStr) {
741  const char *ArgumentEnd = Argument + ArgumentLen;
742  while (true) {
743    assert(Argument < ArgumentEnd && "Plural expression didn't match.");
744    const char *ExprEnd = Argument;
745    while (*ExprEnd != ':') {
746      assert(ExprEnd != ArgumentEnd && "Plural missing expression end");
747      ++ExprEnd;
748    }
749    if (EvalPluralExpr(ValNo, Argument, ExprEnd)) {
750      Argument = ExprEnd + 1;
751      ExprEnd = ScanFormat(Argument, ArgumentEnd, '|');
752
753      // Recursively format the result of the plural clause into the
754      // output string.
755      DInfo.FormatDiagnostic(Argument, ExprEnd, OutStr);
756      return;
757    }
758    Argument = ScanFormat(Argument, ArgumentEnd - 1, '|') + 1;
759  }
760}
761
762/// Returns the friendly description for a token kind that will appear
763/// without quotes in diagnostic messages. These strings may be translatable in
764/// future.
765static const char *getTokenDescForDiagnostic(tok::TokenKind Kind) {
766  switch (Kind) {
767  case tok::identifier:
768    return "identifier";
769  default:
770    return nullptr;
771  }
772}
773
774/// FormatDiagnostic - Format this diagnostic into a string, substituting the
775/// formal arguments into the %0 slots.  The result is appended onto the Str
776/// array.
777void Diagnostic::
778FormatDiagnostic(SmallVectorImpl<char> &OutStr) const {
779  if (!StoredDiagMessage.empty()) {
780    OutStr.append(StoredDiagMessage.begin(), StoredDiagMessage.end());
781    return;
782  }
783
784  StringRef Diag =
785    getDiags()->getDiagnosticIDs()->getDescription(getID());
786
787  FormatDiagnostic(Diag.begin(), Diag.end(), OutStr);
788}
789
790void Diagnostic::
791FormatDiagnostic(const char *DiagStr, const char *DiagEnd,
792                 SmallVectorImpl<char> &OutStr) const {
793  // When the diagnostic string is only "%0", the entire string is being given
794  // by an outside source.  Remove unprintable characters from this string
795  // and skip all the other string processing.
796  if (DiagEnd - DiagStr == 2 &&
797      StringRef(DiagStr, DiagEnd - DiagStr).equals("%0") &&
798      getArgKind(0) == DiagnosticsEngine::ak_std_string) {
799    const std::string &S = getArgStdStr(0);
800    for (char c : S) {
801      if (llvm::sys::locale::isPrint(c) || c == '\t') {
802        OutStr.push_back(c);
803      }
804    }
805    return;
806  }
807
808  /// FormattedArgs - Keep track of all of the arguments formatted by
809  /// ConvertArgToString and pass them into subsequent calls to
810  /// ConvertArgToString, allowing the implementation to avoid redundancies in
811  /// obvious cases.
812  SmallVector<DiagnosticsEngine::ArgumentValue, 8> FormattedArgs;
813
814  /// QualTypeVals - Pass a vector of arrays so that QualType names can be
815  /// compared to see if more information is needed to be printed.
816  SmallVector<intptr_t, 2> QualTypeVals;
817  SmallString<64> Tree;
818
819  for (unsigned i = 0, e = getNumArgs(); i < e; ++i)
820    if (getArgKind(i) == DiagnosticsEngine::ak_qualtype)
821      QualTypeVals.push_back(getRawArg(i));
822
823  while (DiagStr != DiagEnd) {
824    if (DiagStr[0] != '%') {
825      // Append non-%0 substrings to Str if we have one.
826      const char *StrEnd = std::find(DiagStr, DiagEnd, '%');
827      OutStr.append(DiagStr, StrEnd);
828      DiagStr = StrEnd;
829      continue;
830    } else if (isPunctuation(DiagStr[1])) {
831      OutStr.push_back(DiagStr[1]);  // %% -> %.
832      DiagStr += 2;
833      continue;
834    }
835
836    // Skip the %.
837    ++DiagStr;
838
839    // This must be a placeholder for a diagnostic argument.  The format for a
840    // placeholder is one of "%0", "%modifier0", or "%modifier{arguments}0".
841    // The digit is a number from 0-9 indicating which argument this comes from.
842    // The modifier is a string of digits from the set [-a-z]+, arguments is a
843    // brace enclosed string.
844    const char *Modifier = nullptr, *Argument = nullptr;
845    unsigned ModifierLen = 0, ArgumentLen = 0;
846
847    // Check to see if we have a modifier.  If so eat it.
848    if (!isDigit(DiagStr[0])) {
849      Modifier = DiagStr;
850      while (DiagStr[0] == '-' ||
851             (DiagStr[0] >= 'a' && DiagStr[0] <= 'z'))
852        ++DiagStr;
853      ModifierLen = DiagStr-Modifier;
854
855      // If we have an argument, get it next.
856      if (DiagStr[0] == '{') {
857        ++DiagStr; // Skip {.
858        Argument = DiagStr;
859
860        DiagStr = ScanFormat(DiagStr, DiagEnd, '}');
861        assert(DiagStr != DiagEnd && "Mismatched {}'s in diagnostic string!");
862        ArgumentLen = DiagStr-Argument;
863        ++DiagStr;  // Skip }.
864      }
865    }
866
867    assert(isDigit(*DiagStr) && "Invalid format for argument in diagnostic");
868    unsigned ArgNo = *DiagStr++ - '0';
869
870    // Only used for type diffing.
871    unsigned ArgNo2 = ArgNo;
872
873    DiagnosticsEngine::ArgumentKind Kind = getArgKind(ArgNo);
874    if (ModifierIs(Modifier, ModifierLen, "diff")) {
875      assert(*DiagStr == ',' && isDigit(*(DiagStr + 1)) &&
876             "Invalid format for diff modifier");
877      ++DiagStr;  // Comma.
878      ArgNo2 = *DiagStr++ - '0';
879      DiagnosticsEngine::ArgumentKind Kind2 = getArgKind(ArgNo2);
880      if (Kind == DiagnosticsEngine::ak_qualtype &&
881          Kind2 == DiagnosticsEngine::ak_qualtype)
882        Kind = DiagnosticsEngine::ak_qualtype_pair;
883      else {
884        // %diff only supports QualTypes.  For other kinds of arguments,
885        // use the default printing.  For example, if the modifier is:
886        //   "%diff{compare $ to $|other text}1,2"
887        // treat it as:
888        //   "compare %1 to %2"
889        const char *ArgumentEnd = Argument + ArgumentLen;
890        const char *Pipe = ScanFormat(Argument, ArgumentEnd, '|');
891        assert(ScanFormat(Pipe + 1, ArgumentEnd, '|') == ArgumentEnd &&
892               "Found too many '|'s in a %diff modifier!");
893        const char *FirstDollar = ScanFormat(Argument, Pipe, '$');
894        const char *SecondDollar = ScanFormat(FirstDollar + 1, Pipe, '$');
895        const char ArgStr1[] = { '%', static_cast<char>('0' + ArgNo) };
896        const char ArgStr2[] = { '%', static_cast<char>('0' + ArgNo2) };
897        FormatDiagnostic(Argument, FirstDollar, OutStr);
898        FormatDiagnostic(ArgStr1, ArgStr1 + 2, OutStr);
899        FormatDiagnostic(FirstDollar + 1, SecondDollar, OutStr);
900        FormatDiagnostic(ArgStr2, ArgStr2 + 2, OutStr);
901        FormatDiagnostic(SecondDollar + 1, Pipe, OutStr);
902        continue;
903      }
904    }
905
906    switch (Kind) {
907    // ---- STRINGS ----
908    case DiagnosticsEngine::ak_std_string: {
909      const std::string &S = getArgStdStr(ArgNo);
910      assert(ModifierLen == 0 && "No modifiers for strings yet");
911      OutStr.append(S.begin(), S.end());
912      break;
913    }
914    case DiagnosticsEngine::ak_c_string: {
915      const char *S = getArgCStr(ArgNo);
916      assert(ModifierLen == 0 && "No modifiers for strings yet");
917
918      // Don't crash if get passed a null pointer by accident.
919      if (!S)
920        S = "(null)";
921
922      OutStr.append(S, S + strlen(S));
923      break;
924    }
925    // ---- INTEGERS ----
926    case DiagnosticsEngine::ak_sint: {
927      int Val = getArgSInt(ArgNo);
928
929      if (ModifierIs(Modifier, ModifierLen, "select")) {
930        HandleSelectModifier(*this, (unsigned)Val, Argument, ArgumentLen,
931                             OutStr);
932      } else if (ModifierIs(Modifier, ModifierLen, "s")) {
933        HandleIntegerSModifier(Val, OutStr);
934      } else if (ModifierIs(Modifier, ModifierLen, "plural")) {
935        HandlePluralModifier(*this, (unsigned)Val, Argument, ArgumentLen,
936                             OutStr);
937      } else if (ModifierIs(Modifier, ModifierLen, "ordinal")) {
938        HandleOrdinalModifier((unsigned)Val, OutStr);
939      } else {
940        assert(ModifierLen == 0 && "Unknown integer modifier");
941        llvm::raw_svector_ostream(OutStr) << Val;
942      }
943      break;
944    }
945    case DiagnosticsEngine::ak_uint: {
946      unsigned Val = getArgUInt(ArgNo);
947
948      if (ModifierIs(Modifier, ModifierLen, "select")) {
949        HandleSelectModifier(*this, Val, Argument, ArgumentLen, OutStr);
950      } else if (ModifierIs(Modifier, ModifierLen, "s")) {
951        HandleIntegerSModifier(Val, OutStr);
952      } else if (ModifierIs(Modifier, ModifierLen, "plural")) {
953        HandlePluralModifier(*this, (unsigned)Val, Argument, ArgumentLen,
954                             OutStr);
955      } else if (ModifierIs(Modifier, ModifierLen, "ordinal")) {
956        HandleOrdinalModifier(Val, OutStr);
957      } else {
958        assert(ModifierLen == 0 && "Unknown integer modifier");
959        llvm::raw_svector_ostream(OutStr) << Val;
960      }
961      break;
962    }
963    // ---- TOKEN SPELLINGS ----
964    case DiagnosticsEngine::ak_tokenkind: {
965      tok::TokenKind Kind = static_cast<tok::TokenKind>(getRawArg(ArgNo));
966      assert(ModifierLen == 0 && "No modifiers for token kinds yet");
967
968      llvm::raw_svector_ostream Out(OutStr);
969      if (const char *S = tok::getPunctuatorSpelling(Kind))
970        // Quoted token spelling for punctuators.
971        Out << '\'' << S << '\'';
972      else if (const char *S = tok::getKeywordSpelling(Kind))
973        // Unquoted token spelling for keywords.
974        Out << S;
975      else if (const char *S = getTokenDescForDiagnostic(Kind))
976        // Unquoted translatable token name.
977        Out << S;
978      else if (const char *S = tok::getTokenName(Kind))
979        // Debug name, shouldn't appear in user-facing diagnostics.
980        Out << '<' << S << '>';
981      else
982        Out << "(null)";
983      break;
984    }
985    // ---- NAMES and TYPES ----
986    case DiagnosticsEngine::ak_identifierinfo: {
987      const IdentifierInfo *II = getArgIdentifier(ArgNo);
988      assert(ModifierLen == 0 && "No modifiers for strings yet");
989
990      // Don't crash if get passed a null pointer by accident.
991      if (!II) {
992        const char *S = "(null)";
993        OutStr.append(S, S + strlen(S));
994        continue;
995      }
996
997      llvm::raw_svector_ostream(OutStr) << '\'' << II->getName() << '\'';
998      break;
999    }
1000    case DiagnosticsEngine::ak_addrspace:
1001    case DiagnosticsEngine::ak_qual:
1002    case DiagnosticsEngine::ak_qualtype:
1003    case DiagnosticsEngine::ak_declarationname:
1004    case DiagnosticsEngine::ak_nameddecl:
1005    case DiagnosticsEngine::ak_nestednamespec:
1006    case DiagnosticsEngine::ak_declcontext:
1007    case DiagnosticsEngine::ak_attr:
1008      getDiags()->ConvertArgToString(Kind, getRawArg(ArgNo),
1009                                     StringRef(Modifier, ModifierLen),
1010                                     StringRef(Argument, ArgumentLen),
1011                                     FormattedArgs,
1012                                     OutStr, QualTypeVals);
1013      break;
1014    case DiagnosticsEngine::ak_qualtype_pair: {
1015      // Create a struct with all the info needed for printing.
1016      TemplateDiffTypes TDT;
1017      TDT.FromType = getRawArg(ArgNo);
1018      TDT.ToType = getRawArg(ArgNo2);
1019      TDT.ElideType = getDiags()->ElideType;
1020      TDT.ShowColors = getDiags()->ShowColors;
1021      TDT.TemplateDiffUsed = false;
1022      intptr_t val = reinterpret_cast<intptr_t>(&TDT);
1023
1024      const char *ArgumentEnd = Argument + ArgumentLen;
1025      const char *Pipe = ScanFormat(Argument, ArgumentEnd, '|');
1026
1027      // Print the tree.  If this diagnostic already has a tree, skip the
1028      // second tree.
1029      if (getDiags()->PrintTemplateTree && Tree.empty()) {
1030        TDT.PrintFromType = true;
1031        TDT.PrintTree = true;
1032        getDiags()->ConvertArgToString(Kind, val,
1033                                       StringRef(Modifier, ModifierLen),
1034                                       StringRef(Argument, ArgumentLen),
1035                                       FormattedArgs,
1036                                       Tree, QualTypeVals);
1037        // If there is no tree information, fall back to regular printing.
1038        if (!Tree.empty()) {
1039          FormatDiagnostic(Pipe + 1, ArgumentEnd, OutStr);
1040          break;
1041        }
1042      }
1043
1044      // Non-tree printing, also the fall-back when tree printing fails.
1045      // The fall-back is triggered when the types compared are not templates.
1046      const char *FirstDollar = ScanFormat(Argument, ArgumentEnd, '$');
1047      const char *SecondDollar = ScanFormat(FirstDollar + 1, ArgumentEnd, '$');
1048
1049      // Append before text
1050      FormatDiagnostic(Argument, FirstDollar, OutStr);
1051
1052      // Append first type
1053      TDT.PrintTree = false;
1054      TDT.PrintFromType = true;
1055      getDiags()->ConvertArgToString(Kind, val,
1056                                     StringRef(Modifier, ModifierLen),
1057                                     StringRef(Argument, ArgumentLen),
1058                                     FormattedArgs,
1059                                     OutStr, QualTypeVals);
1060      if (!TDT.TemplateDiffUsed)
1061        FormattedArgs.push_back(std::make_pair(DiagnosticsEngine::ak_qualtype,
1062                                               TDT.FromType));
1063
1064      // Append middle text
1065      FormatDiagnostic(FirstDollar + 1, SecondDollar, OutStr);
1066
1067      // Append second type
1068      TDT.PrintFromType = false;
1069      getDiags()->ConvertArgToString(Kind, val,
1070                                     StringRef(Modifier, ModifierLen),
1071                                     StringRef(Argument, ArgumentLen),
1072                                     FormattedArgs,
1073                                     OutStr, QualTypeVals);
1074      if (!TDT.TemplateDiffUsed)
1075        FormattedArgs.push_back(std::make_pair(DiagnosticsEngine::ak_qualtype,
1076                                               TDT.ToType));
1077
1078      // Append end text
1079      FormatDiagnostic(SecondDollar + 1, Pipe, OutStr);
1080      break;
1081    }
1082    }
1083
1084    // Remember this argument info for subsequent formatting operations.  Turn
1085    // std::strings into a null terminated string to make it be the same case as
1086    // all the other ones.
1087    if (Kind == DiagnosticsEngine::ak_qualtype_pair)
1088      continue;
1089    else if (Kind != DiagnosticsEngine::ak_std_string)
1090      FormattedArgs.push_back(std::make_pair(Kind, getRawArg(ArgNo)));
1091    else
1092      FormattedArgs.push_back(std::make_pair(DiagnosticsEngine::ak_c_string,
1093                                        (intptr_t)getArgStdStr(ArgNo).c_str()));
1094  }
1095
1096  // Append the type tree to the end of the diagnostics.
1097  OutStr.append(Tree.begin(), Tree.end());
1098}
1099
1100StoredDiagnostic::StoredDiagnostic(DiagnosticsEngine::Level Level, unsigned ID,
1101                                   StringRef Message)
1102    : ID(ID), Level(Level), Message(Message) {}
1103
1104StoredDiagnostic::StoredDiagnostic(DiagnosticsEngine::Level Level,
1105                                   const Diagnostic &Info)
1106    : ID(Info.getID()), Level(Level) {
1107  assert((Info.getLocation().isInvalid() || Info.hasSourceManager()) &&
1108       "Valid source location without setting a source manager for diagnostic");
1109  if (Info.getLocation().isValid())
1110    Loc = FullSourceLoc(Info.getLocation(), Info.getSourceManager());
1111  SmallString<64> Message;
1112  Info.FormatDiagnostic(Message);
1113  this->Message.assign(Message.begin(), Message.end());
1114  this->Ranges.assign(Info.getRanges().begin(), Info.getRanges().end());
1115  this->FixIts.assign(Info.getFixItHints().begin(), Info.getFixItHints().end());
1116}
1117
1118StoredDiagnostic::StoredDiagnostic(DiagnosticsEngine::Level Level, unsigned ID,
1119                                   StringRef Message, FullSourceLoc Loc,
1120                                   ArrayRef<CharSourceRange> Ranges,
1121                                   ArrayRef<FixItHint> FixIts)
1122    : ID(ID), Level(Level), Loc(Loc), Message(Message),
1123      Ranges(Ranges.begin(), Ranges.end()), FixIts(FixIts.begin(), FixIts.end())
1124{
1125}
1126
1127/// IncludeInDiagnosticCounts - This method (whose default implementation
1128///  returns true) indicates whether the diagnostics handled by this
1129///  DiagnosticConsumer should be included in the number of diagnostics
1130///  reported by DiagnosticsEngine.
1131bool DiagnosticConsumer::IncludeInDiagnosticCounts() const { return true; }
1132
1133void IgnoringDiagConsumer::anchor() {}
1134
1135ForwardingDiagnosticConsumer::~ForwardingDiagnosticConsumer() = default;
1136
1137void ForwardingDiagnosticConsumer::HandleDiagnostic(
1138       DiagnosticsEngine::Level DiagLevel,
1139       const Diagnostic &Info) {
1140  Target.HandleDiagnostic(DiagLevel, Info);
1141}
1142
1143void ForwardingDiagnosticConsumer::clear() {
1144  DiagnosticConsumer::clear();
1145  Target.clear();
1146}
1147
1148bool ForwardingDiagnosticConsumer::IncludeInDiagnosticCounts() const {
1149  return Target.IncludeInDiagnosticCounts();
1150}
1151
1152PartialDiagnostic::DiagStorageAllocator::DiagStorageAllocator() {
1153  for (unsigned I = 0; I != NumCached; ++I)
1154    FreeList[I] = Cached + I;
1155  NumFreeListEntries = NumCached;
1156}
1157
1158PartialDiagnostic::DiagStorageAllocator::~DiagStorageAllocator() {
1159  // Don't assert if we are in a CrashRecovery context, as this invariant may
1160  // be invalidated during a crash.
1161  assert((NumFreeListEntries == NumCached ||
1162          llvm::CrashRecoveryContext::isRecoveringFromCrash()) &&
1163         "A partial is on the lam");
1164}
1165
1166char DiagnosticError::ID;
1167