clang  10.0.0svn
Diagnostic.h
Go to the documentation of this file.
1 //===- Diagnostic.h - C Language Family Diagnostic Handling -----*- C++ -*-===//
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 /// \file
10 /// Defines the Diagnostic-related interfaces.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_BASIC_DIAGNOSTIC_H
15 #define LLVM_CLANG_BASIC_DIAGNOSTIC_H
16 
20 #include "clang/Basic/Specifiers.h"
21 #include "llvm/ADT/ArrayRef.h"
22 #include "llvm/ADT/DenseMap.h"
23 #include "llvm/ADT/IntrusiveRefCntPtr.h"
24 #include "llvm/ADT/SmallVector.h"
25 #include "llvm/ADT/StringRef.h"
26 #include "llvm/ADT/iterator_range.h"
27 #include "llvm/Support/Compiler.h"
28 #include "llvm/Support/Error.h"
29 #include <cassert>
30 #include <cstdint>
31 #include <limits>
32 #include <list>
33 #include <map>
34 #include <memory>
35 #include <string>
36 #include <type_traits>
37 #include <utility>
38 #include <vector>
39 
40 namespace clang {
41 
42 class DeclContext;
43 class DiagnosticBuilder;
44 class DiagnosticConsumer;
45 class IdentifierInfo;
46 class LangOptions;
47 class Preprocessor;
48 class SourceManager;
49 class StoredDiagnostic;
50 
51 namespace tok {
52 
53 enum TokenKind : unsigned short;
54 
55 } // namespace tok
56 
57 /// Annotates a diagnostic with some code that should be
58 /// inserted, removed, or replaced to fix the problem.
59 ///
60 /// This kind of hint should be used when we are certain that the
61 /// introduction, removal, or modification of a particular (small!)
62 /// amount of code will correct a compilation error. The compiler
63 /// should also provide full recovery from such errors, such that
64 /// suppressing the diagnostic output can still result in successful
65 /// compilation.
66 class FixItHint {
67 public:
68  /// Code that should be replaced to correct the error. Empty for an
69  /// insertion hint.
71 
72  /// Code in the specific range that should be inserted in the insertion
73  /// location.
75 
76  /// The actual code to insert at the insertion location, as a
77  /// string.
78  std::string CodeToInsert;
79 
80  bool BeforePreviousInsertions = false;
81 
82  /// Empty code modification hint, indicating that no code
83  /// modification is known.
84  FixItHint() = default;
85 
86  bool isNull() const {
87  return !RemoveRange.isValid();
88  }
89 
90  /// Create a code modification hint that inserts the given
91  /// code string at a specific location.
93  StringRef Code,
94  bool BeforePreviousInsertions = false) {
95  FixItHint Hint;
96  Hint.RemoveRange =
97  CharSourceRange::getCharRange(InsertionLoc, InsertionLoc);
98  Hint.CodeToInsert = Code;
99  Hint.BeforePreviousInsertions = BeforePreviousInsertions;
100  return Hint;
101  }
102 
103  /// Create a code modification hint that inserts the given
104  /// code from \p FromRange at a specific location.
106  CharSourceRange FromRange,
107  bool BeforePreviousInsertions = false) {
108  FixItHint Hint;
109  Hint.RemoveRange =
110  CharSourceRange::getCharRange(InsertionLoc, InsertionLoc);
111  Hint.InsertFromRange = FromRange;
112  Hint.BeforePreviousInsertions = BeforePreviousInsertions;
113  return Hint;
114  }
115 
116  /// Create a code modification hint that removes the given
117  /// source range.
119  FixItHint Hint;
120  Hint.RemoveRange = RemoveRange;
121  return Hint;
122  }
123  static FixItHint CreateRemoval(SourceRange RemoveRange) {
124  return CreateRemoval(CharSourceRange::getTokenRange(RemoveRange));
125  }
126 
127  /// Create a code modification hint that replaces the given
128  /// source range with the given code string.
130  StringRef Code) {
131  FixItHint Hint;
132  Hint.RemoveRange = RemoveRange;
133  Hint.CodeToInsert = Code;
134  return Hint;
135  }
136 
138  StringRef Code) {
139  return CreateReplacement(CharSourceRange::getTokenRange(RemoveRange), Code);
140  }
141 };
142 
143 /// Concrete class used by the front-end to report problems and issues.
144 ///
145 /// This massages the diagnostics (e.g. handling things like "report warnings
146 /// as errors" and passes them off to the DiagnosticConsumer for reporting to
147 /// the user. DiagnosticsEngine is tied to one translation unit and one
148 /// SourceManager.
149 class DiagnosticsEngine : public RefCountedBase<DiagnosticsEngine> {
150 public:
151  /// The level of the diagnostic, after it has been through mapping.
152  enum Level {
159  };
160 
162  /// std::string
164 
165  /// const char *
167 
168  /// int
170 
171  /// unsigned
173 
174  /// enum TokenKind : unsigned
176 
177  /// IdentifierInfo
179 
180  /// Qualifiers
182 
183  /// QualType
185 
186  /// DeclarationName
188 
189  /// NamedDecl *
191 
192  /// NestedNameSpecifier *
194 
195  /// DeclContext *
197 
198  /// pair<QualType, QualType>
200 
201  /// Attr *
202  ak_attr
203  };
204 
205  /// Represents on argument value, which is a union discriminated
206  /// by ArgumentKind, with a value.
207  using ArgumentValue = std::pair<ArgumentKind, intptr_t>;
208 
209 private:
210  // Used by __extension__
211  unsigned char AllExtensionsSilenced = 0;
212 
213  // Treat fatal errors like errors.
214  bool FatalsAsError = false;
215 
216  // Suppress all diagnostics.
217  bool SuppressAllDiagnostics = false;
218 
219  // Elide common types of templates.
220  bool ElideType = true;
221 
222  // Print a tree when comparing templates.
223  bool PrintTemplateTree = false;
224 
225  // Color printing is enabled.
226  bool ShowColors = false;
227 
228  // Which overload candidates to show.
229  OverloadsShown ShowOverloads = Ovl_All;
230 
231  // Cap of # errors emitted, 0 -> no limit.
232  unsigned ErrorLimit = 0;
233 
234  // Cap on depth of template backtrace stack, 0 -> no limit.
235  unsigned TemplateBacktraceLimit = 0;
236 
237  // Cap on depth of constexpr evaluation backtrace stack, 0 -> no limit.
238  unsigned ConstexprBacktraceLimit = 0;
239 
242  DiagnosticConsumer *Client = nullptr;
243  std::unique_ptr<DiagnosticConsumer> Owner;
244  SourceManager *SourceMgr = nullptr;
245 
246  /// Mapping information for diagnostics.
247  ///
248  /// Mapping info is packed into four bits per diagnostic. The low three
249  /// bits are the mapping (an instance of diag::Severity), or zero if unset.
250  /// The high bit is set when the mapping was established as a user mapping.
251  /// If the high bit is clear, then the low bits are set to the default
252  /// value, and should be mapped with -pedantic, -Werror, etc.
253  ///
254  /// A new DiagState is created and kept around when diagnostic pragmas modify
255  /// the state so that we know what is the diagnostic state at any given
256  /// source location.
257  class DiagState {
258  llvm::DenseMap<unsigned, DiagnosticMapping> DiagMap;
259 
260  public:
261  // "Global" configuration state that can actually vary between modules.
262 
263  // Ignore all warnings: -w
264  unsigned IgnoreAllWarnings : 1;
265 
266  // Enable all warnings.
267  unsigned EnableAllWarnings : 1;
268 
269  // Treat warnings like errors.
270  unsigned WarningsAsErrors : 1;
271 
272  // Treat errors like fatal errors.
273  unsigned ErrorsAsFatal : 1;
274 
275  // Suppress warnings in system headers.
276  unsigned SuppressSystemWarnings : 1;
277 
278  // Map extensions to warnings or errors?
280 
281  DiagState()
282  : IgnoreAllWarnings(false), EnableAllWarnings(false),
283  WarningsAsErrors(false), ErrorsAsFatal(false),
284  SuppressSystemWarnings(false) {}
285 
286  using iterator = llvm::DenseMap<unsigned, DiagnosticMapping>::iterator;
287  using const_iterator =
288  llvm::DenseMap<unsigned, DiagnosticMapping>::const_iterator;
289 
290  void setMapping(diag::kind Diag, DiagnosticMapping Info) {
291  DiagMap[Diag] = Info;
292  }
293 
294  DiagnosticMapping lookupMapping(diag::kind Diag) const {
295  return DiagMap.lookup(Diag);
296  }
297 
298  DiagnosticMapping &getOrAddMapping(diag::kind Diag);
299 
300  const_iterator begin() const { return DiagMap.begin(); }
301  const_iterator end() const { return DiagMap.end(); }
302  };
303 
304  /// Keeps and automatically disposes all DiagStates that we create.
305  std::list<DiagState> DiagStates;
306 
307  /// A mapping from files to the diagnostic states for those files. Lazily
308  /// built on demand for files in which the diagnostic state has not changed.
309  class DiagStateMap {
310  public:
311  /// Add an initial diagnostic state.
312  void appendFirst(DiagState *State);
313 
314  /// Add a new latest state point.
315  void append(SourceManager &SrcMgr, SourceLocation Loc, DiagState *State);
316 
317  /// Look up the diagnostic state at a given source location.
318  DiagState *lookup(SourceManager &SrcMgr, SourceLocation Loc) const;
319 
320  /// Determine whether this map is empty.
321  bool empty() const { return Files.empty(); }
322 
323  /// Clear out this map.
324  void clear() {
325  Files.clear();
326  FirstDiagState = CurDiagState = nullptr;
327  CurDiagStateLoc = SourceLocation();
328  }
329 
330  /// Produce a debugging dump of the diagnostic state.
331  LLVM_DUMP_METHOD void dump(SourceManager &SrcMgr,
332  StringRef DiagName = StringRef()) const;
333 
334  /// Grab the most-recently-added state point.
335  DiagState *getCurDiagState() const { return CurDiagState; }
336 
337  /// Get the location at which a diagnostic state was last added.
338  SourceLocation getCurDiagStateLoc() const { return CurDiagStateLoc; }
339 
340  private:
341  friend class ASTReader;
342  friend class ASTWriter;
343 
344  /// Represents a point in source where the diagnostic state was
345  /// modified because of a pragma.
346  ///
347  /// 'Loc' can be null if the point represents the diagnostic state
348  /// modifications done through the command-line.
349  struct DiagStatePoint {
350  DiagState *State;
351  unsigned Offset;
352 
353  DiagStatePoint(DiagState *State, unsigned Offset)
354  : State(State), Offset(Offset) {}
355  };
356 
357  /// Description of the diagnostic states and state transitions for a
358  /// particular FileID.
359  struct File {
360  /// The diagnostic state for the parent file. This is strictly redundant,
361  /// as looking up the DecomposedIncludedLoc for the FileID in the Files
362  /// map would give us this, but we cache it here for performance.
363  File *Parent = nullptr;
364 
365  /// The offset of this file within its parent.
366  unsigned ParentOffset = 0;
367 
368  /// Whether this file has any local (not imported from an AST file)
369  /// diagnostic state transitions.
370  bool HasLocalTransitions = false;
371 
372  /// The points within the file where the state changes. There will always
373  /// be at least one of these (the state on entry to the file).
374  llvm::SmallVector<DiagStatePoint, 4> StateTransitions;
375 
376  DiagState *lookup(unsigned Offset) const;
377  };
378 
379  /// The diagnostic states for each file.
380  mutable std::map<FileID, File> Files;
381 
382  /// The initial diagnostic state.
383  DiagState *FirstDiagState;
384 
385  /// The current diagnostic state.
386  DiagState *CurDiagState;
387 
388  /// The location at which the current diagnostic state was established.
389  SourceLocation CurDiagStateLoc;
390 
391  /// Get the diagnostic state information for a file.
392  File *getFile(SourceManager &SrcMgr, FileID ID) const;
393  };
394 
395  DiagStateMap DiagStatesByLoc;
396 
397  /// Keeps the DiagState that was active during each diagnostic 'push'
398  /// so we can get back at it when we 'pop'.
399  std::vector<DiagState *> DiagStateOnPushStack;
400 
401  DiagState *GetCurDiagState() const {
402  return DiagStatesByLoc.getCurDiagState();
403  }
404 
405  void PushDiagStatePoint(DiagState *State, SourceLocation L);
406 
407  /// Finds the DiagStatePoint that contains the diagnostic state of
408  /// the given source location.
409  DiagState *GetDiagStateForLoc(SourceLocation Loc) const {
410  return SourceMgr ? DiagStatesByLoc.lookup(*SourceMgr, Loc)
411  : DiagStatesByLoc.getCurDiagState();
412  }
413 
414  /// Sticky flag set to \c true when an error is emitted.
415  bool ErrorOccurred;
416 
417  /// Sticky flag set to \c true when an "uncompilable error" occurs.
418  /// I.e. an error that was not upgraded from a warning by -Werror.
419  bool UncompilableErrorOccurred;
420 
421  /// Sticky flag set to \c true when a fatal error is emitted.
422  bool FatalErrorOccurred;
423 
424  /// Indicates that an unrecoverable error has occurred.
425  bool UnrecoverableErrorOccurred;
426 
427  /// Counts for DiagnosticErrorTrap to check whether an error occurred
428  /// during a parsing section, e.g. during parsing a function.
429  unsigned TrapNumErrorsOccurred;
430  unsigned TrapNumUnrecoverableErrorsOccurred;
431 
432  /// The level of the last diagnostic emitted.
433  ///
434  /// This is used to emit continuation diagnostics with the same level as the
435  /// diagnostic that they follow.
436  DiagnosticIDs::Level LastDiagLevel;
437 
438  /// Number of warnings reported
439  unsigned NumWarnings;
440 
441  /// Number of errors reported
442  unsigned NumErrors;
443 
444  /// A function pointer that converts an opaque diagnostic
445  /// argument to a strings.
446  ///
447  /// This takes the modifiers and argument that was present in the diagnostic.
448  ///
449  /// The PrevArgs array indicates the previous arguments formatted for this
450  /// diagnostic. Implementations of this function can use this information to
451  /// avoid redundancy across arguments.
452  ///
453  /// This is a hack to avoid a layering violation between libbasic and libsema.
454  using ArgToStringFnTy = void (*)(
456  StringRef Modifier, StringRef Argument,
457  ArrayRef<ArgumentValue> PrevArgs,
458  SmallVectorImpl<char> &Output,
459  void *Cookie,
460  ArrayRef<intptr_t> QualTypeVals);
461 
462  void *ArgToStringCookie = nullptr;
463  ArgToStringFnTy ArgToStringFn;
464 
465  /// ID of the "delayed" diagnostic, which is a (typically
466  /// fatal) diagnostic that had to be delayed because it was found
467  /// while emitting another diagnostic.
468  unsigned DelayedDiagID;
469 
470  /// First string argument for the delayed diagnostic.
471  std::string DelayedDiagArg1;
472 
473  /// Second string argument for the delayed diagnostic.
474  std::string DelayedDiagArg2;
475 
476  /// Optional flag value.
477  ///
478  /// Some flags accept values, for instance: -Wframe-larger-than=<value> and
479  /// -Rpass=<value>. The content of this string is emitted after the flag name
480  /// and '='.
481  std::string FlagValue;
482 
483 public:
486  DiagnosticConsumer *client = nullptr,
487  bool ShouldOwnClient = true);
488  DiagnosticsEngine(const DiagnosticsEngine &) = delete;
489  DiagnosticsEngine &operator=(const DiagnosticsEngine &) = delete;
491 
492  LLVM_DUMP_METHOD void dump() const;
493  LLVM_DUMP_METHOD void dump(StringRef DiagName) const;
494 
496  return Diags;
497  }
498 
499  /// Retrieve the diagnostic options.
500  DiagnosticOptions &getDiagnosticOptions() const { return *DiagOpts; }
501 
502  using diag_mapping_range = llvm::iterator_range<DiagState::const_iterator>;
503 
504  /// Get the current set of diagnostic mappings.
506  const DiagState &DS = *GetCurDiagState();
507  return diag_mapping_range(DS.begin(), DS.end());
508  }
509 
510  DiagnosticConsumer *getClient() { return Client; }
511  const DiagnosticConsumer *getClient() const { return Client; }
512 
513  /// Determine whether this \c DiagnosticsEngine object own its client.
514  bool ownsClient() const { return Owner != nullptr; }
515 
516  /// Return the current diagnostic client along with ownership of that
517  /// client.
518  std::unique_ptr<DiagnosticConsumer> takeClient() { return std::move(Owner); }
519 
520  bool hasSourceManager() const { return SourceMgr != nullptr; }
521 
523  assert(SourceMgr && "SourceManager not set!");
524  return *SourceMgr;
525  }
526 
528  assert(DiagStatesByLoc.empty() &&
529  "Leftover diag state from a different SourceManager.");
530  SourceMgr = SrcMgr;
531  }
532 
533  //===--------------------------------------------------------------------===//
534  // DiagnosticsEngine characterization methods, used by a client to customize
535  // how diagnostics are emitted.
536  //
537 
538  /// Copies the current DiagMappings and pushes the new copy
539  /// onto the top of the stack.
540  void pushMappings(SourceLocation Loc);
541 
542  /// Pops the current DiagMappings off the top of the stack,
543  /// causing the new top of the stack to be the active mappings.
544  ///
545  /// \returns \c true if the pop happens, \c false if there is only one
546  /// DiagMapping on the stack.
547  bool popMappings(SourceLocation Loc);
548 
549  /// Set the diagnostic client associated with this diagnostic object.
550  ///
551  /// \param ShouldOwnClient true if the diagnostic object should take
552  /// ownership of \c client.
553  void setClient(DiagnosticConsumer *client, bool ShouldOwnClient = true);
554 
555  /// Specify a limit for the number of errors we should
556  /// emit before giving up.
557  ///
558  /// Zero disables the limit.
559  void setErrorLimit(unsigned Limit) { ErrorLimit = Limit; }
560 
561  /// Specify the maximum number of template instantiation
562  /// notes to emit along with a given diagnostic.
563  void setTemplateBacktraceLimit(unsigned Limit) {
564  TemplateBacktraceLimit = Limit;
565  }
566 
567  /// Retrieve the maximum number of template instantiation
568  /// notes to emit along with a given diagnostic.
569  unsigned getTemplateBacktraceLimit() const {
570  return TemplateBacktraceLimit;
571  }
572 
573  /// Specify the maximum number of constexpr evaluation
574  /// notes to emit along with a given diagnostic.
575  void setConstexprBacktraceLimit(unsigned Limit) {
576  ConstexprBacktraceLimit = Limit;
577  }
578 
579  /// Retrieve the maximum number of constexpr evaluation
580  /// notes to emit along with a given diagnostic.
581  unsigned getConstexprBacktraceLimit() const {
582  return ConstexprBacktraceLimit;
583  }
584 
585  /// When set to true, any unmapped warnings are ignored.
586  ///
587  /// If this and WarningsAsErrors are both set, then this one wins.
588  void setIgnoreAllWarnings(bool Val) {
589  GetCurDiagState()->IgnoreAllWarnings = Val;
590  }
591  bool getIgnoreAllWarnings() const {
592  return GetCurDiagState()->IgnoreAllWarnings;
593  }
594 
595  /// When set to true, any unmapped ignored warnings are no longer
596  /// ignored.
597  ///
598  /// If this and IgnoreAllWarnings are both set, then that one wins.
599  void setEnableAllWarnings(bool Val) {
600  GetCurDiagState()->EnableAllWarnings = Val;
601  }
602  bool getEnableAllWarnings() const {
603  return GetCurDiagState()->EnableAllWarnings;
604  }
605 
606  /// When set to true, any warnings reported are issued as errors.
607  void setWarningsAsErrors(bool Val) {
608  GetCurDiagState()->WarningsAsErrors = Val;
609  }
610  bool getWarningsAsErrors() const {
611  return GetCurDiagState()->WarningsAsErrors;
612  }
613 
614  /// When set to true, any error reported is made a fatal error.
615  void setErrorsAsFatal(bool Val) { GetCurDiagState()->ErrorsAsFatal = Val; }
616  bool getErrorsAsFatal() const { return GetCurDiagState()->ErrorsAsFatal; }
617 
618  /// \brief When set to true, any fatal error reported is made an error.
619  ///
620  /// This setting takes precedence over the setErrorsAsFatal setting above.
621  void setFatalsAsError(bool Val) { FatalsAsError = Val; }
622  bool getFatalsAsError() const { return FatalsAsError; }
623 
624  /// When set to true mask warnings that come from system headers.
625  void setSuppressSystemWarnings(bool Val) {
626  GetCurDiagState()->SuppressSystemWarnings = Val;
627  }
629  return GetCurDiagState()->SuppressSystemWarnings;
630  }
631 
632  /// Suppress all diagnostics, to silence the front end when we
633  /// know that we don't want any more diagnostics to be passed along to the
634  /// client
635  void setSuppressAllDiagnostics(bool Val = true) {
636  SuppressAllDiagnostics = Val;
637  }
638  bool getSuppressAllDiagnostics() const { return SuppressAllDiagnostics; }
639 
640  /// Set type eliding, to skip outputting same types occurring in
641  /// template types.
642  void setElideType(bool Val = true) { ElideType = Val; }
643  bool getElideType() { return ElideType; }
644 
645  /// Set tree printing, to outputting the template difference in a
646  /// tree format.
647  void setPrintTemplateTree(bool Val = false) { PrintTemplateTree = Val; }
648  bool getPrintTemplateTree() { return PrintTemplateTree; }
649 
650  /// Set color printing, so the type diffing will inject color markers
651  /// into the output.
652  void setShowColors(bool Val = false) { ShowColors = Val; }
653  bool getShowColors() { return ShowColors; }
654 
655  /// Specify which overload candidates to show when overload resolution
656  /// fails.
657  ///
658  /// By default, we show all candidates.
660  ShowOverloads = Val;
661  }
662  OverloadsShown getShowOverloads() const { return ShowOverloads; }
663 
664  /// Pretend that the last diagnostic issued was ignored, so any
665  /// subsequent notes will be suppressed, or restore a prior ignoring
666  /// state after ignoring some diagnostics and their notes, possibly in
667  /// the middle of another diagnostic.
668  ///
669  /// This can be used by clients who suppress diagnostics themselves.
670  void setLastDiagnosticIgnored(bool Ignored = true) {
671  if (LastDiagLevel == DiagnosticIDs::Fatal)
672  FatalErrorOccurred = true;
673  LastDiagLevel = Ignored ? DiagnosticIDs::Ignored : DiagnosticIDs::Warning;
674  }
675 
676  /// Determine whether the previous diagnostic was ignored. This can
677  /// be used by clients that want to determine whether notes attached to a
678  /// diagnostic will be suppressed.
679  bool isLastDiagnosticIgnored() const {
680  return LastDiagLevel == DiagnosticIDs::Ignored;
681  }
682 
683  /// Controls whether otherwise-unmapped extension diagnostics are
684  /// mapped onto ignore/warning/error.
685  ///
686  /// This corresponds to the GCC -pedantic and -pedantic-errors option.
688  GetCurDiagState()->ExtBehavior = H;
689  }
691  return GetCurDiagState()->ExtBehavior;
692  }
693 
694  /// Counter bumped when an __extension__ block is/ encountered.
695  ///
696  /// When non-zero, all extension diagnostics are entirely silenced, no
697  /// matter how they are mapped.
698  void IncrementAllExtensionsSilenced() { ++AllExtensionsSilenced; }
699  void DecrementAllExtensionsSilenced() { --AllExtensionsSilenced; }
700  bool hasAllExtensionsSilenced() { return AllExtensionsSilenced != 0; }
701 
702  /// This allows the client to specify that certain warnings are
703  /// ignored.
704  ///
705  /// Notes can never be mapped, errors can only be mapped to fatal, and
706  /// WARNINGs and EXTENSIONs can be mapped arbitrarily.
707  ///
708  /// \param Loc The source location that this change of diagnostic state should
709  /// take affect. It can be null if we are setting the latest state.
710  void setSeverity(diag::kind Diag, diag::Severity Map, SourceLocation Loc);
711 
712  /// Change an entire diagnostic group (e.g. "unknown-pragmas") to
713  /// have the specified mapping.
714  ///
715  /// \returns true (and ignores the request) if "Group" was unknown, false
716  /// otherwise.
717  ///
718  /// \param Flavor The flavor of group to affect. -Rfoo does not affect the
719  /// state of the -Wfoo group and vice versa.
720  ///
721  /// \param Loc The source location that this change of diagnostic state should
722  /// take affect. It can be null if we are setting the state from command-line.
723  bool setSeverityForGroup(diag::Flavor Flavor, StringRef Group,
724  diag::Severity Map,
726 
727  /// Set the warning-as-error flag for the given diagnostic group.
728  ///
729  /// This function always only operates on the current diagnostic state.
730  ///
731  /// \returns True if the given group is unknown, false otherwise.
732  bool setDiagnosticGroupWarningAsError(StringRef Group, bool Enabled);
733 
734  /// Set the error-as-fatal flag for the given diagnostic group.
735  ///
736  /// This function always only operates on the current diagnostic state.
737  ///
738  /// \returns True if the given group is unknown, false otherwise.
739  bool setDiagnosticGroupErrorAsFatal(StringRef Group, bool Enabled);
740 
741  /// Add the specified mapping to all diagnostics of the specified
742  /// flavor.
743  ///
744  /// Mainly to be used by -Wno-everything to disable all warnings but allow
745  /// subsequent -W options to enable specific warnings.
746  void setSeverityForAll(diag::Flavor Flavor, diag::Severity Map,
748 
749  bool hasErrorOccurred() const { return ErrorOccurred; }
750 
751  /// Errors that actually prevent compilation, not those that are
752  /// upgraded from a warning by -Werror.
754  return UncompilableErrorOccurred;
755  }
756  bool hasFatalErrorOccurred() const { return FatalErrorOccurred; }
757 
758  /// Determine whether any kind of unrecoverable error has occurred.
760  return FatalErrorOccurred || UnrecoverableErrorOccurred;
761  }
762 
763  unsigned getNumWarnings() const { return NumWarnings; }
764 
765  void setNumWarnings(unsigned NumWarnings) {
766  this->NumWarnings = NumWarnings;
767  }
768 
769  /// Return an ID for a diagnostic with the specified format string and
770  /// level.
771  ///
772  /// If this is the first request for this diagnostic, it is registered and
773  /// created, otherwise the existing ID is returned.
774  ///
775  /// \param FormatString A fixed diagnostic format string that will be hashed
776  /// and mapped to a unique DiagID.
777  template <unsigned N>
778  unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) {
779  return Diags->getCustomDiagID((DiagnosticIDs::Level)L,
780  StringRef(FormatString, N - 1));
781  }
782 
783  /// Converts a diagnostic argument (as an intptr_t) into the string
784  /// that represents it.
786  StringRef Modifier, StringRef Argument,
787  ArrayRef<ArgumentValue> PrevArgs,
788  SmallVectorImpl<char> &Output,
789  ArrayRef<intptr_t> QualTypeVals) const {
790  ArgToStringFn(Kind, Val, Modifier, Argument, PrevArgs, Output,
791  ArgToStringCookie, QualTypeVals);
792  }
793 
794  void SetArgToStringFn(ArgToStringFnTy Fn, void *Cookie) {
795  ArgToStringFn = Fn;
796  ArgToStringCookie = Cookie;
797  }
798 
799  /// Note that the prior diagnostic was emitted by some other
800  /// \c DiagnosticsEngine, and we may be attaching a note to that diagnostic.
802  LastDiagLevel = Other.LastDiagLevel;
803  }
804 
805  /// Reset the state of the diagnostic object to its initial
806  /// configuration.
807  void Reset();
808 
809  //===--------------------------------------------------------------------===//
810  // DiagnosticsEngine classification and reporting interfaces.
811  //
812 
813  /// Determine whether the diagnostic is known to be ignored.
814  ///
815  /// This can be used to opportunistically avoid expensive checks when it's
816  /// known for certain that the diagnostic has been suppressed at the
817  /// specified location \p Loc.
818  ///
819  /// \param Loc The source location we are interested in finding out the
820  /// diagnostic state. Can be null in order to query the latest state.
821  bool isIgnored(unsigned DiagID, SourceLocation Loc) const {
822  return Diags->getDiagnosticSeverity(DiagID, Loc, *this) ==
824  }
825 
826  /// Based on the way the client configured the DiagnosticsEngine
827  /// object, classify the specified diagnostic ID into a Level, consumable by
828  /// the DiagnosticConsumer.
829  ///
830  /// To preserve invariant assumptions, this function should not be used to
831  /// influence parse or semantic analysis actions. Instead consider using
832  /// \c isIgnored().
833  ///
834  /// \param Loc The source location we are interested in finding out the
835  /// diagnostic state. Can be null in order to query the latest state.
836  Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const {
837  return (Level)Diags->getDiagnosticLevel(DiagID, Loc, *this);
838  }
839 
840  /// Issue the message to the client.
841  ///
842  /// This actually returns an instance of DiagnosticBuilder which emits the
843  /// diagnostics (through @c ProcessDiag) when it is destroyed.
844  ///
845  /// \param DiagID A member of the @c diag::kind enum.
846  /// \param Loc Represents the source location associated with the diagnostic,
847  /// which can be an invalid location if no position information is available.
848  inline DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID);
849  inline DiagnosticBuilder Report(unsigned DiagID);
850 
851  void Report(const StoredDiagnostic &storedDiag);
852 
853  /// Determine whethere there is already a diagnostic in flight.
854  bool isDiagnosticInFlight() const {
855  return CurDiagID != std::numeric_limits<unsigned>::max();
856  }
857 
858  /// Set the "delayed" diagnostic that will be emitted once
859  /// the current diagnostic completes.
860  ///
861  /// If a diagnostic is already in-flight but the front end must
862  /// report a problem (e.g., with an inconsistent file system
863  /// state), this routine sets a "delayed" diagnostic that will be
864  /// emitted after the current diagnostic completes. This should
865  /// only be used for fatal errors detected at inconvenient
866  /// times. If emitting a delayed diagnostic causes a second delayed
867  /// diagnostic to be introduced, that second delayed diagnostic
868  /// will be ignored.
869  ///
870  /// \param DiagID The ID of the diagnostic being delayed.
871  ///
872  /// \param Arg1 A string argument that will be provided to the
873  /// diagnostic. A copy of this string will be stored in the
874  /// DiagnosticsEngine object itself.
875  ///
876  /// \param Arg2 A string argument that will be provided to the
877  /// diagnostic. A copy of this string will be stored in the
878  /// DiagnosticsEngine object itself.
879  void SetDelayedDiagnostic(unsigned DiagID, StringRef Arg1 = "",
880  StringRef Arg2 = "");
881 
882  /// Clear out the current diagnostic.
883  void Clear() { CurDiagID = std::numeric_limits<unsigned>::max(); }
884 
885  /// Return the value associated with this diagnostic flag.
886  StringRef getFlagValue() const { return FlagValue; }
887 
888 private:
889  // This is private state used by DiagnosticBuilder. We put it here instead of
890  // in DiagnosticBuilder in order to keep DiagnosticBuilder a small lightweight
891  // object. This implementation choice means that we can only have one
892  // diagnostic "in flight" at a time, but this seems to be a reasonable
893  // tradeoff to keep these objects small. Assertions verify that only one
894  // diagnostic is in flight at a time.
895  friend class Diagnostic;
896  friend class DiagnosticBuilder;
897  friend class DiagnosticErrorTrap;
898  friend class DiagnosticIDs;
899  friend class PartialDiagnostic;
900 
901  /// Report the delayed diagnostic.
902  void ReportDelayed();
903 
904  /// The location of the current diagnostic that is in flight.
905  SourceLocation CurDiagLoc;
906 
907  /// The ID of the current diagnostic that is in flight.
908  ///
909  /// This is set to std::numeric_limits<unsigned>::max() when there is no
910  /// diagnostic in flight.
911  unsigned CurDiagID;
912 
913  enum {
914  /// The maximum number of arguments we can hold.
915  ///
916  /// We currently only support up to 10 arguments (%0-%9). A single
917  /// diagnostic with more than that almost certainly has to be simplified
918  /// anyway.
919  MaxArguments = 10,
920  };
921 
922  /// The number of entries in Arguments.
923  signed char NumDiagArgs;
924 
925  /// Specifies whether an argument is in DiagArgumentsStr or
926  /// in DiagArguments.
927  ///
928  /// This is an array of ArgumentKind::ArgumentKind enum values, one for each
929  /// argument.
930  unsigned char DiagArgumentsKind[MaxArguments];
931 
932  /// Holds the values of each string argument for the current
933  /// diagnostic.
934  ///
935  /// This is only used when the corresponding ArgumentKind is ak_std_string.
936  std::string DiagArgumentsStr[MaxArguments];
937 
938  /// The values for the various substitution positions.
939  ///
940  /// This is used when the argument is not an std::string. The specific
941  /// value is mangled into an intptr_t and the interpretation depends on
942  /// exactly what sort of argument kind it is.
943  intptr_t DiagArgumentsVal[MaxArguments];
944 
945  /// The list of ranges added to this diagnostic.
947 
948  /// If valid, provides a hint with some code to insert, remove,
949  /// or modify at a particular position.
950  SmallVector<FixItHint, 8> DiagFixItHints;
951 
952  DiagnosticMapping makeUserMapping(diag::Severity Map, SourceLocation L) {
953  bool isPragma = L.isValid();
954  DiagnosticMapping Mapping =
955  DiagnosticMapping::Make(Map, /*IsUser=*/true, isPragma);
956 
957  // If this is a pragma mapping, then set the diagnostic mapping flags so
958  // that we override command line options.
959  if (isPragma) {
960  Mapping.setNoWarningAsError(true);
961  Mapping.setNoErrorAsFatal(true);
962  }
963 
964  return Mapping;
965  }
966 
967  /// Used to report a diagnostic that is finally fully formed.
968  ///
969  /// \returns true if the diagnostic was emitted, false if it was suppressed.
970  bool ProcessDiag() {
971  return Diags->ProcessDiag(*this);
972  }
973 
974  /// @name Diagnostic Emission
975  /// @{
976 protected:
977  friend class ASTReader;
978  friend class ASTWriter;
979 
980  // Sema requires access to the following functions because the current design
981  // of SFINAE requires it to use its own SemaDiagnosticBuilder, which needs to
982  // access us directly to ensure we minimize the emitted code for the common
983  // Sema::Diag() patterns.
984  friend class Sema;
985 
986  /// Emit the current diagnostic and clear the diagnostic state.
987  ///
988  /// \param Force Emit the diagnostic regardless of suppression settings.
989  bool EmitCurrentDiagnostic(bool Force = false);
990 
991  unsigned getCurrentDiagID() const { return CurDiagID; }
992 
993  SourceLocation getCurrentDiagLoc() const { return CurDiagLoc; }
994 
995  /// @}
996 };
997 
998 /// RAII class that determines when any errors have occurred
999 /// between the time the instance was created and the time it was
1000 /// queried.
1003  unsigned NumErrors;
1004  unsigned NumUnrecoverableErrors;
1005 
1006 public:
1008  : Diag(Diag) { reset(); }
1009 
1010  /// Determine whether any errors have occurred since this
1011  /// object instance was created.
1012  bool hasErrorOccurred() const {
1013  return Diag.TrapNumErrorsOccurred > NumErrors;
1014  }
1015 
1016  /// Determine whether any unrecoverable errors have occurred since this
1017  /// object instance was created.
1019  return Diag.TrapNumUnrecoverableErrorsOccurred > NumUnrecoverableErrors;
1020  }
1021 
1022  /// Set to initial state of "no errors occurred".
1023  void reset() {
1024  NumErrors = Diag.TrapNumErrorsOccurred;
1025  NumUnrecoverableErrors = Diag.TrapNumUnrecoverableErrorsOccurred;
1026  }
1027 };
1028 
1029 //===----------------------------------------------------------------------===//
1030 // DiagnosticBuilder
1031 //===----------------------------------------------------------------------===//
1032 
1033 /// A little helper class used to produce diagnostics.
1034 ///
1035 /// This is constructed by the DiagnosticsEngine::Report method, and
1036 /// allows insertion of extra information (arguments and source ranges) into
1037 /// the currently "in flight" diagnostic. When the temporary for the builder
1038 /// is destroyed, the diagnostic is issued.
1039 ///
1040 /// Note that many of these will be created as temporary objects (many call
1041 /// sites), so we want them to be small and we never want their address taken.
1042 /// This ensures that compilers with somewhat reasonable optimizers will promote
1043 /// the common fields to registers, eliminating increments of the NumArgs field,
1044 /// for example.
1046  friend class DiagnosticsEngine;
1047  friend class PartialDiagnostic;
1048 
1049  mutable DiagnosticsEngine *DiagObj = nullptr;
1050  mutable unsigned NumArgs = 0;
1051 
1052  /// Status variable indicating if this diagnostic is still active.
1053  ///
1054  // NOTE: This field is redundant with DiagObj (IsActive iff (DiagObj == 0)),
1055  // but LLVM is not currently smart enough to eliminate the null check that
1056  // Emit() would end up with if we used that as our status variable.
1057  mutable bool IsActive = false;
1058 
1059  /// Flag indicating that this diagnostic is being emitted via a
1060  /// call to ForceEmit.
1061  mutable bool IsForceEmit = false;
1062 
1063  DiagnosticBuilder() = default;
1064 
1065  explicit DiagnosticBuilder(DiagnosticsEngine *diagObj)
1066  : DiagObj(diagObj), IsActive(true) {
1067  assert(diagObj && "DiagnosticBuilder requires a valid DiagnosticsEngine!");
1068  diagObj->DiagRanges.clear();
1069  diagObj->DiagFixItHints.clear();
1070  }
1071 
1072 protected:
1073  void FlushCounts() {
1074  DiagObj->NumDiagArgs = NumArgs;
1075  }
1076 
1077  /// Clear out the current diagnostic.
1078  void Clear() const {
1079  DiagObj = nullptr;
1080  IsActive = false;
1081  IsForceEmit = false;
1082  }
1083 
1084  /// Determine whether this diagnostic is still active.
1085  bool isActive() const { return IsActive; }
1086 
1087  /// Force the diagnostic builder to emit the diagnostic now.
1088  ///
1089  /// Once this function has been called, the DiagnosticBuilder object
1090  /// should not be used again before it is destroyed.
1091  ///
1092  /// \returns true if a diagnostic was emitted, false if the
1093  /// diagnostic was suppressed.
1094  bool Emit() {
1095  // If this diagnostic is inactive, then its soul was stolen by the copy ctor
1096  // (or by a subclass, as in SemaDiagnosticBuilder).
1097  if (!isActive()) return false;
1098 
1099  // When emitting diagnostics, we set the final argument count into
1100  // the DiagnosticsEngine object.
1101  FlushCounts();
1102 
1103  // Process the diagnostic.
1104  bool Result = DiagObj->EmitCurrentDiagnostic(IsForceEmit);
1105 
1106  // This diagnostic is dead.
1107  Clear();
1108 
1109  return Result;
1110  }
1111 
1112 public:
1113  /// Copy constructor. When copied, this "takes" the diagnostic info from the
1114  /// input and neuters it.
1116  DiagObj = D.DiagObj;
1117  IsActive = D.IsActive;
1118  IsForceEmit = D.IsForceEmit;
1119  D.Clear();
1120  NumArgs = D.NumArgs;
1121  }
1122 
1123  DiagnosticBuilder &operator=(const DiagnosticBuilder &) = delete;
1124 
1125  /// Emits the diagnostic.
1127  Emit();
1128  }
1129 
1130  /// Retrieve an empty diagnostic builder.
1132  return {};
1133  }
1134 
1135  /// Forces the diagnostic to be emitted.
1137  IsForceEmit = true;
1138  return *this;
1139  }
1140 
1141  /// Conversion of DiagnosticBuilder to bool always returns \c true.
1142  ///
1143  /// This allows is to be used in boolean error contexts (where \c true is
1144  /// used to indicate that an error has occurred), like:
1145  /// \code
1146  /// return Diag(...);
1147  /// \endcode
1148  operator bool() const { return true; }
1149 
1150  void AddString(StringRef S) const {
1151  assert(isActive() && "Clients must not add to cleared diagnostic!");
1152  assert(NumArgs < DiagnosticsEngine::MaxArguments &&
1153  "Too many arguments to diagnostic!");
1154  DiagObj->DiagArgumentsKind[NumArgs] = DiagnosticsEngine::ak_std_string;
1155  DiagObj->DiagArgumentsStr[NumArgs++] = S;
1156  }
1157 
1159  assert(isActive() && "Clients must not add to cleared diagnostic!");
1160  assert(NumArgs < DiagnosticsEngine::MaxArguments &&
1161  "Too many arguments to diagnostic!");
1162  DiagObj->DiagArgumentsKind[NumArgs] = Kind;
1163  DiagObj->DiagArgumentsVal[NumArgs++] = V;
1164  }
1165 
1166  void AddSourceRange(const CharSourceRange &R) const {
1167  assert(isActive() && "Clients must not add to cleared diagnostic!");
1168  DiagObj->DiagRanges.push_back(R);
1169  }
1170 
1171  void AddFixItHint(const FixItHint &Hint) const {
1172  assert(isActive() && "Clients must not add to cleared diagnostic!");
1173  if (!Hint.isNull())
1174  DiagObj->DiagFixItHints.push_back(Hint);
1175  }
1176 
1177  void addFlagValue(StringRef V) const { DiagObj->FlagValue = V; }
1178 };
1179 
1181  StringRef Val;
1182 
1183  explicit AddFlagValue(StringRef V) : Val(V) {}
1184 };
1185 
1186 /// Register a value for the flag in the current diagnostic. This
1187 /// value will be shown as the suffix "=value" after the flag name. It is
1188 /// useful in cases where the diagnostic flag accepts values (e.g.,
1189 /// -Rpass or -Wframe-larger-than).
1191  const AddFlagValue V) {
1192  DB.addFlagValue(V.Val);
1193  return DB;
1194 }
1195 
1197  StringRef S) {
1198  DB.AddString(S);
1199  return DB;
1200 }
1201 
1203  const char *Str) {
1204  DB.AddTaggedVal(reinterpret_cast<intptr_t>(Str),
1206  return DB;
1207 }
1208 
1209 inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB, int I) {
1211  return DB;
1212 }
1213 
1214 // We use enable_if here to prevent that this overload is selected for
1215 // pointers or other arguments that are implicitly convertible to bool.
1216 template <typename T>
1217 inline
1218 typename std::enable_if<std::is_same<T, bool>::value,
1219  const DiagnosticBuilder &>::type
1222  return DB;
1223 }
1224 
1226  unsigned I) {
1228  return DB;
1229 }
1230 
1232  tok::TokenKind I) {
1233  DB.AddTaggedVal(static_cast<unsigned>(I), DiagnosticsEngine::ak_tokenkind);
1234  return DB;
1235 }
1236 
1238  const IdentifierInfo *II) {
1239  DB.AddTaggedVal(reinterpret_cast<intptr_t>(II),
1241  return DB;
1242 }
1243 
1244 // Adds a DeclContext to the diagnostic. The enable_if template magic is here
1245 // so that we only match those arguments that are (statically) DeclContexts;
1246 // other arguments that derive from DeclContext (e.g., RecordDecls) will not
1247 // match.
1248 template <typename T>
1249 inline typename std::enable_if<
1251  const DiagnosticBuilder &>::type
1252 operator<<(const DiagnosticBuilder &DB, T *DC) {
1253  DB.AddTaggedVal(reinterpret_cast<intptr_t>(DC),
1255  return DB;
1256 }
1257 
1259  SourceRange R) {
1261  return DB;
1262 }
1263 
1265  ArrayRef<SourceRange> Ranges) {
1266  for (SourceRange R : Ranges)
1268  return DB;
1269 }
1270 
1272  const CharSourceRange &R) {
1273  DB.AddSourceRange(R);
1274  return DB;
1275 }
1276 
1278  const FixItHint &Hint) {
1279  DB.AddFixItHint(Hint);
1280  return DB;
1281 }
1282 
1284  ArrayRef<FixItHint> Hints) {
1285  for (const FixItHint &Hint : Hints)
1286  DB.AddFixItHint(Hint);
1287  return DB;
1288 }
1289 
1290 /// A nullability kind paired with a bit indicating whether it used a
1291 /// context-sensitive keyword.
1292 using DiagNullabilityKind = std::pair<NullabilityKind, bool>;
1293 
1295  DiagNullabilityKind nullability);
1296 
1298  unsigned DiagID) {
1299  assert(CurDiagID == std::numeric_limits<unsigned>::max() &&
1300  "Multiple diagnostics in flight at once!");
1301  CurDiagLoc = Loc;
1302  CurDiagID = DiagID;
1303  FlagValue.clear();
1304  return DiagnosticBuilder(this);
1305 }
1306 
1308  llvm::Error &&E) {
1309  DB.AddString(toString(std::move(E)));
1310  return DB;
1311 }
1312 
1314  return Report(SourceLocation(), DiagID);
1315 }
1316 
1317 //===----------------------------------------------------------------------===//
1318 // Diagnostic
1319 //===----------------------------------------------------------------------===//
1320 
1321 /// A little helper class (which is basically a smart pointer that forwards
1322 /// info from DiagnosticsEngine) that allows clients to enquire about the
1323 /// currently in-flight diagnostic.
1324 class Diagnostic {
1325  const DiagnosticsEngine *DiagObj;
1326  StringRef StoredDiagMessage;
1327 
1328 public:
1329  explicit Diagnostic(const DiagnosticsEngine *DO) : DiagObj(DO) {}
1330  Diagnostic(const DiagnosticsEngine *DO, StringRef storedDiagMessage)
1331  : DiagObj(DO), StoredDiagMessage(storedDiagMessage) {}
1332 
1333  const DiagnosticsEngine *getDiags() const { return DiagObj; }
1334  unsigned getID() const { return DiagObj->CurDiagID; }
1335  const SourceLocation &getLocation() const { return DiagObj->CurDiagLoc; }
1336  bool hasSourceManager() const { return DiagObj->hasSourceManager(); }
1337  SourceManager &getSourceManager() const { return DiagObj->getSourceManager();}
1338 
1339  unsigned getNumArgs() const { return DiagObj->NumDiagArgs; }
1340 
1341  /// Return the kind of the specified index.
1342  ///
1343  /// Based on the kind of argument, the accessors below can be used to get
1344  /// the value.
1345  ///
1346  /// \pre Idx < getNumArgs()
1348  assert(Idx < getNumArgs() && "Argument index out of range!");
1349  return (DiagnosticsEngine::ArgumentKind)DiagObj->DiagArgumentsKind[Idx];
1350  }
1351 
1352  /// Return the provided argument string specified by \p Idx.
1353  /// \pre getArgKind(Idx) == DiagnosticsEngine::ak_std_string
1354  const std::string &getArgStdStr(unsigned Idx) const {
1355  assert(getArgKind(Idx) == DiagnosticsEngine::ak_std_string &&
1356  "invalid argument accessor!");
1357  return DiagObj->DiagArgumentsStr[Idx];
1358  }
1359 
1360  /// Return the specified C string argument.
1361  /// \pre getArgKind(Idx) == DiagnosticsEngine::ak_c_string
1362  const char *getArgCStr(unsigned Idx) const {
1363  assert(getArgKind(Idx) == DiagnosticsEngine::ak_c_string &&
1364  "invalid argument accessor!");
1365  return reinterpret_cast<const char*>(DiagObj->DiagArgumentsVal[Idx]);
1366  }
1367 
1368  /// Return the specified signed integer argument.
1369  /// \pre getArgKind(Idx) == DiagnosticsEngine::ak_sint
1370  int getArgSInt(unsigned Idx) const {
1371  assert(getArgKind(Idx) == DiagnosticsEngine::ak_sint &&
1372  "invalid argument accessor!");
1373  return (int)DiagObj->DiagArgumentsVal[Idx];
1374  }
1375 
1376  /// Return the specified unsigned integer argument.
1377  /// \pre getArgKind(Idx) == DiagnosticsEngine::ak_uint
1378  unsigned getArgUInt(unsigned Idx) const {
1379  assert(getArgKind(Idx) == DiagnosticsEngine::ak_uint &&
1380  "invalid argument accessor!");
1381  return (unsigned)DiagObj->DiagArgumentsVal[Idx];
1382  }
1383 
1384  /// Return the specified IdentifierInfo argument.
1385  /// \pre getArgKind(Idx) == DiagnosticsEngine::ak_identifierinfo
1386  const IdentifierInfo *getArgIdentifier(unsigned Idx) const {
1387  assert(getArgKind(Idx) == DiagnosticsEngine::ak_identifierinfo &&
1388  "invalid argument accessor!");
1389  return reinterpret_cast<IdentifierInfo*>(DiagObj->DiagArgumentsVal[Idx]);
1390  }
1391 
1392  /// Return the specified non-string argument in an opaque form.
1393  /// \pre getArgKind(Idx) != DiagnosticsEngine::ak_std_string
1394  intptr_t getRawArg(unsigned Idx) const {
1395  assert(getArgKind(Idx) != DiagnosticsEngine::ak_std_string &&
1396  "invalid argument accessor!");
1397  return DiagObj->DiagArgumentsVal[Idx];
1398  }
1399 
1400  /// Return the number of source ranges associated with this diagnostic.
1401  unsigned getNumRanges() const {
1402  return DiagObj->DiagRanges.size();
1403  }
1404 
1405  /// \pre Idx < getNumRanges()
1406  const CharSourceRange &getRange(unsigned Idx) const {
1407  assert(Idx < getNumRanges() && "Invalid diagnostic range index!");
1408  return DiagObj->DiagRanges[Idx];
1409  }
1410 
1411  /// Return an array reference for this diagnostic's ranges.
1413  return DiagObj->DiagRanges;
1414  }
1415 
1416  unsigned getNumFixItHints() const {
1417  return DiagObj->DiagFixItHints.size();
1418  }
1419 
1420  const FixItHint &getFixItHint(unsigned Idx) const {
1421  assert(Idx < getNumFixItHints() && "Invalid index!");
1422  return DiagObj->DiagFixItHints[Idx];
1423  }
1424 
1426  return DiagObj->DiagFixItHints;
1427  }
1428 
1429  /// Format this diagnostic into a string, substituting the
1430  /// formal arguments into the %0 slots.
1431  ///
1432  /// The result is appended onto the \p OutStr array.
1433  void FormatDiagnostic(SmallVectorImpl<char> &OutStr) const;
1434 
1435  /// Format the given format-string into the output buffer using the
1436  /// arguments stored in this diagnostic.
1437  void FormatDiagnostic(const char *DiagStr, const char *DiagEnd,
1438  SmallVectorImpl<char> &OutStr) const;
1439 };
1440 
1441 /**
1442  * Represents a diagnostic in a form that can be retained until its
1443  * corresponding source manager is destroyed.
1444  */
1446  unsigned ID;
1448  FullSourceLoc Loc;
1449  std::string Message;
1450  std::vector<CharSourceRange> Ranges;
1451  std::vector<FixItHint> FixIts;
1452 
1453 public:
1454  StoredDiagnostic() = default;
1456  StoredDiagnostic(DiagnosticsEngine::Level Level, unsigned ID,
1457  StringRef Message);
1458  StoredDiagnostic(DiagnosticsEngine::Level Level, unsigned ID,
1459  StringRef Message, FullSourceLoc Loc,
1461  ArrayRef<FixItHint> Fixits);
1462 
1463  /// Evaluates true when this object stores a diagnostic.
1464  explicit operator bool() const { return !Message.empty(); }
1465 
1466  unsigned getID() const { return ID; }
1468  const FullSourceLoc &getLocation() const { return Loc; }
1469  StringRef getMessage() const { return Message; }
1470 
1471  void setLocation(FullSourceLoc Loc) { this->Loc = Loc; }
1472 
1473  using range_iterator = std::vector<CharSourceRange>::const_iterator;
1474 
1475  range_iterator range_begin() const { return Ranges.begin(); }
1476  range_iterator range_end() const { return Ranges.end(); }
1477  unsigned range_size() const { return Ranges.size(); }
1478 
1480  return llvm::makeArrayRef(Ranges);
1481  }
1482 
1483  using fixit_iterator = std::vector<FixItHint>::const_iterator;
1484 
1485  fixit_iterator fixit_begin() const { return FixIts.begin(); }
1486  fixit_iterator fixit_end() const { return FixIts.end(); }
1487  unsigned fixit_size() const { return FixIts.size(); }
1488 
1490  return llvm::makeArrayRef(FixIts);
1491  }
1492 };
1493 
1494 /// Abstract interface, implemented by clients of the front-end, which
1495 /// formats and prints fully processed diagnostics.
1497 protected:
1498  unsigned NumWarnings = 0; ///< Number of warnings reported
1499  unsigned NumErrors = 0; ///< Number of errors reported
1500 
1501 public:
1502  DiagnosticConsumer() = default;
1503  virtual ~DiagnosticConsumer();
1504 
1505  unsigned getNumErrors() const { return NumErrors; }
1506  unsigned getNumWarnings() const { return NumWarnings; }
1507  virtual void clear() { NumWarnings = NumErrors = 0; }
1508 
1509  /// Callback to inform the diagnostic client that processing
1510  /// of a source file is beginning.
1511  ///
1512  /// Note that diagnostics may be emitted outside the processing of a source
1513  /// file, for example during the parsing of command line options. However,
1514  /// diagnostics with source range information are required to only be emitted
1515  /// in between BeginSourceFile() and EndSourceFile().
1516  ///
1517  /// \param LangOpts The language options for the source file being processed.
1518  /// \param PP The preprocessor object being used for the source; this is
1519  /// optional, e.g., it may not be present when processing AST source files.
1520  virtual void BeginSourceFile(const LangOptions &LangOpts,
1521  const Preprocessor *PP = nullptr) {}
1522 
1523  /// Callback to inform the diagnostic client that processing
1524  /// of a source file has ended.
1525  ///
1526  /// The diagnostic client should assume that any objects made available via
1527  /// BeginSourceFile() are inaccessible.
1528  virtual void EndSourceFile() {}
1529 
1530  /// Callback to inform the diagnostic client that processing of all
1531  /// source files has ended.
1532  virtual void finish() {}
1533 
1534  /// Indicates whether the diagnostics handled by this
1535  /// DiagnosticConsumer should be included in the number of diagnostics
1536  /// reported by DiagnosticsEngine.
1537  ///
1538  /// The default implementation returns true.
1539  virtual bool IncludeInDiagnosticCounts() const;
1540 
1541  /// Handle this diagnostic, reporting it to the user or
1542  /// capturing it to a log as needed.
1543  ///
1544  /// The default implementation just keeps track of the total number of
1545  /// warnings and errors.
1546  virtual void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
1547  const Diagnostic &Info);
1548 };
1549 
1550 /// A diagnostic client that ignores all diagnostics.
1552  virtual void anchor();
1553 
1554  void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
1555  const Diagnostic &Info) override {
1556  // Just ignore it.
1557  }
1558 };
1559 
1560 /// Diagnostic consumer that forwards diagnostics along to an
1561 /// existing, already-initialized diagnostic consumer.
1562 ///
1565 
1566 public:
1568  ~ForwardingDiagnosticConsumer() override;
1569 
1570  void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
1571  const Diagnostic &Info) override;
1572  void clear() override;
1573 
1574  bool IncludeInDiagnosticCounts() const override;
1575 };
1576 
1577 // Struct used for sending info about how a type should be printed.
1581  unsigned PrintTree : 1;
1582  unsigned PrintFromType : 1;
1583  unsigned ElideType : 1;
1584  unsigned ShowColors : 1;
1585 
1586  // The printer sets this variable to true if the template diff was used.
1587  unsigned TemplateDiffUsed : 1;
1588 };
1589 
1590 /// Special character that the diagnostic printer will use to toggle the bold
1591 /// attribute. The character itself will be not be printed.
1592 const char ToggleHighlight = 127;
1593 
1594 /// ProcessWarningOptions - Initialize the diagnostic client and process the
1595 /// warning options specified on the command line.
1597  const DiagnosticOptions &Opts,
1598  bool ReportDiags = true);
1599 
1600 } // namespace clang
1601 
1602 #endif // LLVM_CLANG_BASIC_DIAGNOSTIC_H
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
unsigned getTemplateBacktraceLimit() const
Retrieve the maximum number of template instantiation notes to emit along with a given diagnostic...
Definition: Diagnostic.h:569
unsigned getID() const
Definition: Diagnostic.h:1466
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
static FixItHint CreateRemoval(SourceRange RemoveRange)
Definition: Diagnostic.h:123
bool hasErrorOccurred() const
Definition: Diagnostic.h:749
DiagnosticConsumer * getClient()
Definition: Diagnostic.h:510
unsigned fixit_size() const
Definition: Diagnostic.h:1487
fixit_iterator fixit_end() const
Definition: Diagnostic.h:1486
void setShowColors(bool Val=false)
Set color printing, so the type diffing will inject color markers into the output.
Definition: Diagnostic.h:652
void AddFixItHint(const FixItHint &Hint) const
Definition: Diagnostic.h:1171
SourceManager & getSourceManager() const
Definition: Diagnostic.h:522
bool getEnableAllWarnings() const
Definition: Diagnostic.h:602
bool getFatalsAsError() const
Definition: Diagnostic.h:622
range_iterator range_begin() const
Definition: Diagnostic.h:1475
static CharSourceRange getTokenRange(SourceRange R)
void setShowOverloads(OverloadsShown Val)
Specify which overload candidates to show when overload resolution fails.
Definition: Diagnostic.h:659
~DiagnosticBuilder()
Emits the diagnostic.
Definition: Diagnostic.h:1126
Represents a diagnostic in a form that can be retained until its corresponding source manager is dest...
Definition: Diagnostic.h:1445
const DiagnosticBuilder & operator<<(const DiagnosticBuilder &DB, const Attr *At)
Definition: Attr.h:335
Show all overloads.
std::string CodeToInsert
The actual code to insert at the insertion location, as a string.
Definition: Diagnostic.h:78
const DiagnosticBuilder & setForceEmit() const
Forces the diagnostic to be emitted.
Definition: Diagnostic.h:1136
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1297
virtual void clear()
static FixItHint CreateInsertionFromRange(SourceLocation InsertionLoc, CharSourceRange FromRange, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code from FromRange at a specific location...
Definition: Diagnostic.h:105
DiagnosticsEngine::ArgumentKind getArgKind(unsigned Idx) const
Return the kind of the specified index.
Definition: Diagnostic.h:1347
unsigned range_size() const
Definition: Diagnostic.h:1477
range_iterator range_end() const
Definition: Diagnostic.h:1476
bool getSuppressSystemWarnings() const
Definition: Diagnostic.h:628
std::unique_ptr< DiagnosticConsumer > takeClient()
Return the current diagnostic client along with ownership of that client.
Definition: Diagnostic.h:518
diag::Severity getExtensionHandlingBehavior() const
Definition: Diagnostic.h:690
const std::string & getArgStdStr(unsigned Idx) const
Return the provided argument string specified by Idx.
Definition: Diagnostic.h:1354
virtual void EndSourceFile()
Callback to inform the diagnostic client that processing of a source file has ended.
Definition: Diagnostic.h:1528
Severity
Enum values that allow the client to map NOTEs, WARNINGs, and EXTENSIONs to either Ignore (nothing)...
Definition: DiagnosticIDs.h:79
Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...
Definition: Diagnostic.h:1496
RAII class that determines when any errors have occurred between the time the instance was created an...
Definition: Diagnostic.h:1001
void setTemplateBacktraceLimit(unsigned Limit)
Specify the maximum number of template instantiation notes to emit along with a given diagnostic...
Definition: Diagnostic.h:563
bool hasSourceManager() const
Definition: Diagnostic.h:1336
unsigned getID() const
Definition: Diagnostic.h:1334
const DiagnosticsEngine * getDiags() const
Definition: Diagnostic.h:1333
void AddTaggedVal(intptr_t V, DiagnosticsEngine::ArgumentKind Kind) const
Definition: Diagnostic.h:1158
One of these records is kept for each identifier that is lexed.
unsigned getCurrentDiagID() const
Definition: Diagnostic.h:991
const DiagnosticConsumer * getClient() const
Definition: Diagnostic.h:511
LineState State
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
void IncrementAllExtensionsSilenced()
Counter bumped when an extension block is/ encountered.
Definition: Diagnostic.h:698
unsigned getNumErrors() const
Definition: Diagnostic.h:1505
const FixItHint & getFixItHint(unsigned Idx) const
Definition: Diagnostic.h:1420
void setExtensionHandlingBehavior(diag::Severity H)
Controls whether otherwise-unmapped extension diagnostics are mapped onto ignore/warning/error.
Definition: Diagnostic.h:687
bool isNull() const
Definition: Diagnostic.h:86
ForwardingDiagnosticConsumer(DiagnosticConsumer &Target)
Definition: Diagnostic.h:1567
__DEVICE__ int max(int __a, int __b)
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:49
static DiagnosticBuilder getEmpty()
Retrieve an empty diagnostic builder.
Definition: Diagnostic.h:1131
void setPrintTemplateTree(bool Val=false)
Set tree printing, to outputting the template difference in a tree format.
Definition: Diagnostic.h:647
void setSourceManager(SourceManager *SrcMgr)
Definition: Diagnostic.h:527
unsigned getArgUInt(unsigned Idx) const
Return the specified unsigned integer argument.
Definition: Diagnostic.h:1378
bool isActive() const
Determine whether this diagnostic is still active.
Definition: Diagnostic.h:1085
StringRef getFlagValue() const
Return the value associated with this diagnostic flag.
Definition: Diagnostic.h:886
const SourceLocation & getLocation() const
Definition: Diagnostic.h:1335
static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef< CounterExpression > Expressions, ArrayRef< CounterMappingRegion > Regions)
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:149
bool hasUnrecoverableErrorOccurred() const
Determine whether any kind of unrecoverable error has occurred.
Definition: Diagnostic.h:759
bool isDiagnosticInFlight() const
Determine whethere there is already a diagnostic in flight.
Definition: Diagnostic.h:854
intptr_t getRawArg(unsigned Idx) const
Return the specified non-string argument in an opaque form.
Definition: Diagnostic.h:1394
ArrayRef< CharSourceRange > getRanges() const
Definition: Diagnostic.h:1479
DiagnosticBuilder(const DiagnosticBuilder &D)
Copy constructor.
Definition: Diagnostic.h:1115
SourceLocation getCurrentDiagLoc() const
Definition: Diagnostic.h:993
StringRef getMessage() const
Definition: Diagnostic.h:1469
Diagnostic(const DiagnosticsEngine *DO, StringRef storedDiagMessage)
Definition: Diagnostic.h:1330
void setFatalsAsError(bool Val)
When set to true, any fatal error reported is made an error.
Definition: Diagnostic.h:621
bool EmitCurrentDiagnostic(bool Force=false)
Emit the current diagnostic and clear the diagnostic state.
Definition: Diagnostic.cpp:497
NodeId Parent
Definition: ASTDiff.cpp:191
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:328
A little helper class used to produce diagnostics.
Definition: Diagnostic.h:1045
unsigned Offset
Definition: Format.cpp:1714
Represents a character-granular source range.
DiagnosticsEngine::Level getLevel() const
Definition: Diagnostic.h:1467
DiagnosticErrorTrap(DiagnosticsEngine &Diag)
Definition: Diagnostic.h:1007
bool hasUncompilableErrorOccurred() const
Errors that actually prevent compilation, not those that are upgraded from a warning by -Werror...
Definition: Diagnostic.h:753
unsigned getNumRanges() const
Return the number of source ranges associated with this diagnostic.
Definition: Diagnostic.h:1401
ArrayRef< FixItHint > getFixIts() const
Definition: Diagnostic.h:1489
void addFlagValue(StringRef V) const
Definition: Diagnostic.h:1177
#define V(N, I)
Definition: ASTContext.h:2907
const char * getArgCStr(unsigned Idx) const
Return the specified C string argument.
Definition: Diagnostic.h:1362
void setElideType(bool Val=true)
Set type eliding, to skip outputting same types occurring in template types.
Definition: Diagnostic.h:642
#define bool
Definition: stdbool.h:15
const IdentifierInfo * getArgIdentifier(unsigned Idx) const
Return the specified IdentifierInfo argument.
Definition: Diagnostic.h:1386
AddFlagValue(StringRef V)
Definition: Diagnostic.h:1183
void Clear()
Clear out the current diagnostic.
Definition: Diagnostic.h:883
bool BeforePreviousInsertions
Definition: Diagnostic.h:80
void setEnableAllWarnings(bool Val)
When set to true, any unmapped ignored warnings are no longer ignored.
Definition: Diagnostic.h:599
fixit_iterator fixit_begin() const
Definition: Diagnostic.h:1485
OverloadsShown getShowOverloads() const
Definition: Diagnostic.h:662
CharSourceRange InsertFromRange
Code in the specific range that should be inserted in the insertion location.
Definition: Diagnostic.h:74
unsigned getNumWarnings() const
Definition: Diagnostic.h:763
static CharSourceRange getCharRange(SourceRange R)
CharSourceRange RemoveRange
Code that should be replaced to correct the error.
Definition: Diagnostic.h:70
void AddSourceRange(const CharSourceRange &R) const
Definition: Diagnostic.h:1166
__INTPTR_TYPE__ intptr_t
A signed integer type with the property that any valid pointer to void can be converted to this type...
Definition: opencl-c-base.h:55
Kind
void Clear() const
Clear out the current diagnostic.
Definition: Diagnostic.h:1078
const CharSourceRange & getRange(unsigned Idx) const
Definition: Diagnostic.h:1406
void setSuppressSystemWarnings(bool Val)
When set to true mask warnings that come from system headers.
Definition: Diagnostic.h:625
Encodes a location in the source.
bool hasErrorOccurred() const
Determine whether any errors have occurred since this object instance was created.
Definition: Diagnostic.h:1012
bool isLastDiagnosticIgnored() const
Determine whether the previous diagnostic was ignored.
Definition: Diagnostic.h:679
std::pair< NullabilityKind, bool > DiagNullabilityKind
A nullability kind paired with a bit indicating whether it used a context-sensitive keyword...
Definition: Diagnostic.h:1292
unsigned getNumWarnings() const
Definition: Diagnostic.h:1506
Options for controlling the compiler diagnostics engine.
diag_mapping_range getDiagnosticMappings() const
Get the current set of diagnostic mappings.
Definition: Diagnostic.h:505
virtual void finish()
Callback to inform the diagnostic client that processing of all source files has ended.
Definition: Diagnostic.h:1532
void ConvertArgToString(ArgumentKind Kind, intptr_t Val, StringRef Modifier, StringRef Argument, ArrayRef< ArgumentValue > PrevArgs, SmallVectorImpl< char > &Output, ArrayRef< intptr_t > QualTypeVals) const
Converts a diagnostic argument (as an intptr_t) into the string that represents it.
Definition: Diagnostic.h:785
const char ToggleHighlight
Special character that the diagnostic printer will use to toggle the bold attribute.
Definition: Diagnostic.h:1592
Diagnostic consumer that forwards diagnostics along to an existing, already-initialized diagnostic co...
Definition: Diagnostic.h:1563
void ProcessWarningOptions(DiagnosticsEngine &Diags, const DiagnosticOptions &Opts, bool ReportDiags=true)
ProcessWarningOptions - Initialize the diagnostic client and process the warning options specified on...
Definition: Warnings.cpp:43
void reset()
Set to initial state of "no errors occurred".
Definition: Diagnostic.h:1023
void AddString(StringRef S) const
Definition: Diagnostic.h:1150
OpenMPLinearClauseKind Modifier
Modifier of &#39;linear&#39; clause.
Definition: OpenMPClause.h:101
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:24
void SetArgToStringFn(ArgToStringFnTy Fn, void *Cookie)
Definition: Diagnostic.h:794
std::pair< ArgumentKind, intptr_t > ArgumentValue
Represents on argument value, which is a union discriminated by ArgumentKind, with a value...
Definition: Diagnostic.h:207
void setNoErrorAsFatal(bool Value)
Flavor
Flavors of diagnostics we can emit.
Definition: DiagnosticIDs.h:90
SourceManager & getSourceManager() const
Definition: Diagnostic.h:1337
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
Definition: Diagnostic.h:778
void setNumWarnings(unsigned NumWarnings)
Definition: Diagnostic.h:765
static DiagnosticMapping Make(diag::Severity Severity, bool IsUser, bool IsPragma)
void setLastDiagnosticIgnored(bool Ignored=true)
Pretend that the last diagnostic issued was ignored, so any subsequent notes will be suppressed...
Definition: Diagnostic.h:670
bool getIgnoreAllWarnings() const
Definition: Diagnostic.h:591
Defines various enumerations that describe declaration and type specifiers.
void setErrorLimit(unsigned Limit)
Specify a limit for the number of errors we should emit before giving up.
Definition: Diagnostic.h:559
void setIgnoreAllWarnings(bool Val)
When set to true, any unmapped warnings are ignored.
Definition: Diagnostic.h:588
std::vector< FixItHint >::const_iterator fixit_iterator
Definition: Diagnostic.h:1483
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Dataflow Directional Tag Classes.
A diagnostic client that ignores all diagnostics.
Definition: Diagnostic.h:1551
Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const
Based on the way the client configured the DiagnosticsEngine object, classify the specified diagnosti...
Definition: Diagnostic.h:836
bool isValid() const
Return true if this is a valid SourceLocation object.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1271
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:354
const FullSourceLoc & getLocation() const
Definition: Diagnostic.h:1468
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:118
Level
The level of the diagnostic, after it has been through mapping.
Used for handling and querying diagnostic IDs.
bool hasUnrecoverableErrorOccurred() const
Determine whether any unrecoverable errors have occurred since this object instance was created...
Definition: Diagnostic.h:1018
DiagnosticOptions & getDiagnosticOptions() const
Retrieve the diagnostic options.
Definition: Diagnostic.h:500
void setErrorsAsFatal(bool Val)
When set to true, any error reported is made a fatal error.
Definition: Diagnostic.h:615
void setWarningsAsErrors(bool Val)
When set to true, any warnings reported are issued as errors.
Definition: Diagnostic.h:607
unsigned getNumFixItHints() const
Definition: Diagnostic.h:1416
void setConstexprBacktraceLimit(unsigned Limit)
Specify the maximum number of constexpr evaluation notes to emit along with a given diagnostic...
Definition: Diagnostic.h:575
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:92
Diagnostic(const DiagnosticsEngine *DO)
Definition: Diagnostic.h:1329
unsigned getConstexprBacktraceLimit() const
Retrieve the maximum number of constexpr evaluation notes to emit along with a given diagnostic...
Definition: Diagnostic.h:581
bool hasFatalErrorOccurred() const
Definition: Diagnostic.h:756
llvm::iterator_range< DiagState::const_iterator > diag_mapping_range
Definition: Diagnostic.h:502
void DecrementAllExtensionsSilenced()
Definition: Diagnostic.h:699
int getArgSInt(unsigned Idx) const
Return the specified signed integer argument.
Definition: Diagnostic.h:1370
const IntrusiveRefCntPtr< DiagnosticIDs > & getDiagnosticIDs() const
Definition: Diagnostic.h:495
void setSuppressAllDiagnostics(bool Val=true)
Suppress all diagnostics, to silence the front end when we know that we don&#39;t want any more diagnosti...
Definition: Diagnostic.h:635
static FixItHint CreateReplacement(SourceRange RemoveRange, StringRef Code)
Definition: Diagnostic.h:137
Defines the clang::SourceLocation class and associated facilities.
ArrayRef< CharSourceRange > getRanges() const
Return an array reference for this diagnostic&#39;s ranges.
Definition: Diagnostic.h:1412
ArrayRef< FixItHint > getFixItHints() const
Definition: Diagnostic.h:1425
OverloadsShown
Specifies which overload candidates to display when overload resolution fails.
Level
The level of the diagnostic, after it has been through mapping.
Definition: Diagnostic.h:152
Do not present this diagnostic, ignore it.
bool hasSourceManager() const
Definition: Diagnostic.h:520
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:60
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:129
Writes an AST file containing the contents of a translation unit.
Definition: ASTWriter.h:103
unsigned getNumArgs() const
Definition: Diagnostic.h:1339
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1324
A SourceLocation and its associated SourceManager.
Defines the Diagnostic IDs-related interfaces.
bool getErrorsAsFatal() const
Definition: Diagnostic.h:616
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:821
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:66
void setNoWarningAsError(bool Value)
bool getWarningsAsErrors() const
Definition: Diagnostic.h:610
bool Emit()
Force the diagnostic builder to emit the diagnostic now.
Definition: Diagnostic.h:1094
#define true
Definition: stdbool.h:16
A trivial tuple used to represent a source range.
void setLocation(FullSourceLoc Loc)
Definition: Diagnostic.h:1471
virtual void BeginSourceFile(const LangOptions &LangOpts, const Preprocessor *PP=nullptr)
Callback to inform the diagnostic client that processing of a source file is beginning.
Definition: Diagnostic.h:1520
std::vector< CharSourceRange >::const_iterator range_iterator
Definition: Diagnostic.h:1473
This class handles loading and caching of source files into memory.
bool getSuppressAllDiagnostics() const
Definition: Diagnostic.h:638
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:124
bool ownsClient() const
Determine whether this DiagnosticsEngine object own its client.
Definition: Diagnostic.h:514
enum TokenKind : unsigned
Definition: Diagnostic.h:175
void notePriorDiagnosticFrom(const DiagnosticsEngine &Other)
Note that the prior diagnostic was emitted by some other DiagnosticsEngine, and we may be attaching a...
Definition: Diagnostic.h:801