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) { SuppressAllDiagnostics = Val; }
636  bool getSuppressAllDiagnostics() const { return SuppressAllDiagnostics; }
637 
638  /// Set type eliding, to skip outputting same types occurring in
639  /// template types.
640  void setElideType(bool Val) { ElideType = Val; }
641  bool getElideType() { return ElideType; }
642 
643  /// Set tree printing, to outputting the template difference in a
644  /// tree format.
645  void setPrintTemplateTree(bool Val) { PrintTemplateTree = Val; }
646  bool getPrintTemplateTree() { return PrintTemplateTree; }
647 
648  /// Set color printing, so the type diffing will inject color markers
649  /// into the output.
650  void setShowColors(bool Val) { ShowColors = Val; }
651  bool getShowColors() { return ShowColors; }
652 
653  /// Specify which overload candidates to show when overload resolution
654  /// fails.
655  ///
656  /// By default, we show all candidates.
658  ShowOverloads = Val;
659  }
660  OverloadsShown getShowOverloads() const { return ShowOverloads; }
661 
662  /// Pretend that the last diagnostic issued was ignored, so any
663  /// subsequent notes will be suppressed, or restore a prior ignoring
664  /// state after ignoring some diagnostics and their notes, possibly in
665  /// the middle of another diagnostic.
666  ///
667  /// This can be used by clients who suppress diagnostics themselves.
668  void setLastDiagnosticIgnored(bool Ignored) {
669  if (LastDiagLevel == DiagnosticIDs::Fatal)
670  FatalErrorOccurred = true;
671  LastDiagLevel = Ignored ? DiagnosticIDs::Ignored : DiagnosticIDs::Warning;
672  }
673 
674  /// Determine whether the previous diagnostic was ignored. This can
675  /// be used by clients that want to determine whether notes attached to a
676  /// diagnostic will be suppressed.
677  bool isLastDiagnosticIgnored() const {
678  return LastDiagLevel == DiagnosticIDs::Ignored;
679  }
680 
681  /// Controls whether otherwise-unmapped extension diagnostics are
682  /// mapped onto ignore/warning/error.
683  ///
684  /// This corresponds to the GCC -pedantic and -pedantic-errors option.
686  GetCurDiagState()->ExtBehavior = H;
687  }
689  return GetCurDiagState()->ExtBehavior;
690  }
691 
692  /// Counter bumped when an __extension__ block is/ encountered.
693  ///
694  /// When non-zero, all extension diagnostics are entirely silenced, no
695  /// matter how they are mapped.
696  void IncrementAllExtensionsSilenced() { ++AllExtensionsSilenced; }
697  void DecrementAllExtensionsSilenced() { --AllExtensionsSilenced; }
698  bool hasAllExtensionsSilenced() { return AllExtensionsSilenced != 0; }
699 
700  /// This allows the client to specify that certain warnings are
701  /// ignored.
702  ///
703  /// Notes can never be mapped, errors can only be mapped to fatal, and
704  /// WARNINGs and EXTENSIONs can be mapped arbitrarily.
705  ///
706  /// \param Loc The source location that this change of diagnostic state should
707  /// take affect. It can be null if we are setting the latest state.
708  void setSeverity(diag::kind Diag, diag::Severity Map, SourceLocation Loc);
709 
710  /// Change an entire diagnostic group (e.g. "unknown-pragmas") to
711  /// have the specified mapping.
712  ///
713  /// \returns true (and ignores the request) if "Group" was unknown, false
714  /// otherwise.
715  ///
716  /// \param Flavor The flavor of group to affect. -Rfoo does not affect the
717  /// state of the -Wfoo group and vice versa.
718  ///
719  /// \param Loc The source location that this change of diagnostic state should
720  /// take affect. It can be null if we are setting the state from command-line.
721  bool setSeverityForGroup(diag::Flavor Flavor, StringRef Group,
722  diag::Severity Map,
724 
725  /// Set the warning-as-error flag for the given diagnostic group.
726  ///
727  /// This function always only operates on the current diagnostic state.
728  ///
729  /// \returns True if the given group is unknown, false otherwise.
730  bool setDiagnosticGroupWarningAsError(StringRef Group, bool Enabled);
731 
732  /// Set the error-as-fatal flag for the given diagnostic group.
733  ///
734  /// This function always only operates on the current diagnostic state.
735  ///
736  /// \returns True if the given group is unknown, false otherwise.
737  bool setDiagnosticGroupErrorAsFatal(StringRef Group, bool Enabled);
738 
739  /// Add the specified mapping to all diagnostics of the specified
740  /// flavor.
741  ///
742  /// Mainly to be used by -Wno-everything to disable all warnings but allow
743  /// subsequent -W options to enable specific warnings.
744  void setSeverityForAll(diag::Flavor Flavor, diag::Severity Map,
746 
747  bool hasErrorOccurred() const { return ErrorOccurred; }
748 
749  /// Errors that actually prevent compilation, not those that are
750  /// upgraded from a warning by -Werror.
752  return UncompilableErrorOccurred;
753  }
754  bool hasFatalErrorOccurred() const { return FatalErrorOccurred; }
755 
756  /// Determine whether any kind of unrecoverable error has occurred.
758  return FatalErrorOccurred || UnrecoverableErrorOccurred;
759  }
760 
761  unsigned getNumWarnings() const { return NumWarnings; }
762 
763  void setNumWarnings(unsigned NumWarnings) {
764  this->NumWarnings = NumWarnings;
765  }
766 
767  /// Return an ID for a diagnostic with the specified format string and
768  /// level.
769  ///
770  /// If this is the first request for this diagnostic, it is registered and
771  /// created, otherwise the existing ID is returned.
772  ///
773  /// \param FormatString A fixed diagnostic format string that will be hashed
774  /// and mapped to a unique DiagID.
775  template <unsigned N>
776  unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) {
777  return Diags->getCustomDiagID((DiagnosticIDs::Level)L,
778  StringRef(FormatString, N - 1));
779  }
780 
781  /// Converts a diagnostic argument (as an intptr_t) into the string
782  /// that represents it.
784  StringRef Modifier, StringRef Argument,
785  ArrayRef<ArgumentValue> PrevArgs,
786  SmallVectorImpl<char> &Output,
787  ArrayRef<intptr_t> QualTypeVals) const {
788  ArgToStringFn(Kind, Val, Modifier, Argument, PrevArgs, Output,
789  ArgToStringCookie, QualTypeVals);
790  }
791 
792  void SetArgToStringFn(ArgToStringFnTy Fn, void *Cookie) {
793  ArgToStringFn = Fn;
794  ArgToStringCookie = Cookie;
795  }
796 
797  /// Note that the prior diagnostic was emitted by some other
798  /// \c DiagnosticsEngine, and we may be attaching a note to that diagnostic.
800  LastDiagLevel = Other.LastDiagLevel;
801  }
802 
803  /// Reset the state of the diagnostic object to its initial
804  /// configuration.
805  void Reset();
806 
807  //===--------------------------------------------------------------------===//
808  // DiagnosticsEngine classification and reporting interfaces.
809  //
810 
811  /// Determine whether the diagnostic is known to be ignored.
812  ///
813  /// This can be used to opportunistically avoid expensive checks when it's
814  /// known for certain that the diagnostic has been suppressed at the
815  /// specified location \p Loc.
816  ///
817  /// \param Loc The source location we are interested in finding out the
818  /// diagnostic state. Can be null in order to query the latest state.
819  bool isIgnored(unsigned DiagID, SourceLocation Loc) const {
820  return Diags->getDiagnosticSeverity(DiagID, Loc, *this) ==
822  }
823 
824  /// Based on the way the client configured the DiagnosticsEngine
825  /// object, classify the specified diagnostic ID into a Level, consumable by
826  /// the DiagnosticConsumer.
827  ///
828  /// To preserve invariant assumptions, this function should not be used to
829  /// influence parse or semantic analysis actions. Instead consider using
830  /// \c isIgnored().
831  ///
832  /// \param Loc The source location we are interested in finding out the
833  /// diagnostic state. Can be null in order to query the latest state.
834  Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const {
835  return (Level)Diags->getDiagnosticLevel(DiagID, Loc, *this);
836  }
837 
838  /// Issue the message to the client.
839  ///
840  /// This actually returns an instance of DiagnosticBuilder which emits the
841  /// diagnostics (through @c ProcessDiag) when it is destroyed.
842  ///
843  /// \param DiagID A member of the @c diag::kind enum.
844  /// \param Loc Represents the source location associated with the diagnostic,
845  /// which can be an invalid location if no position information is available.
846  inline DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID);
847  inline DiagnosticBuilder Report(unsigned DiagID);
848 
849  void Report(const StoredDiagnostic &storedDiag);
850 
851  /// Determine whethere there is already a diagnostic in flight.
852  bool isDiagnosticInFlight() const {
853  return CurDiagID != std::numeric_limits<unsigned>::max();
854  }
855 
856  /// Set the "delayed" diagnostic that will be emitted once
857  /// the current diagnostic completes.
858  ///
859  /// If a diagnostic is already in-flight but the front end must
860  /// report a problem (e.g., with an inconsistent file system
861  /// state), this routine sets a "delayed" diagnostic that will be
862  /// emitted after the current diagnostic completes. This should
863  /// only be used for fatal errors detected at inconvenient
864  /// times. If emitting a delayed diagnostic causes a second delayed
865  /// diagnostic to be introduced, that second delayed diagnostic
866  /// will be ignored.
867  ///
868  /// \param DiagID The ID of the diagnostic being delayed.
869  ///
870  /// \param Arg1 A string argument that will be provided to the
871  /// diagnostic. A copy of this string will be stored in the
872  /// DiagnosticsEngine object itself.
873  ///
874  /// \param Arg2 A string argument that will be provided to the
875  /// diagnostic. A copy of this string will be stored in the
876  /// DiagnosticsEngine object itself.
877  void SetDelayedDiagnostic(unsigned DiagID, StringRef Arg1 = "",
878  StringRef Arg2 = "");
879 
880  /// Clear out the current diagnostic.
881  void Clear() { CurDiagID = std::numeric_limits<unsigned>::max(); }
882 
883  /// Return the value associated with this diagnostic flag.
884  StringRef getFlagValue() const { return FlagValue; }
885 
886 private:
887  // This is private state used by DiagnosticBuilder. We put it here instead of
888  // in DiagnosticBuilder in order to keep DiagnosticBuilder a small lightweight
889  // object. This implementation choice means that we can only have one
890  // diagnostic "in flight" at a time, but this seems to be a reasonable
891  // tradeoff to keep these objects small. Assertions verify that only one
892  // diagnostic is in flight at a time.
893  friend class Diagnostic;
894  friend class DiagnosticBuilder;
895  friend class DiagnosticErrorTrap;
896  friend class DiagnosticIDs;
897  friend class PartialDiagnostic;
898 
899  /// Report the delayed diagnostic.
900  void ReportDelayed();
901 
902  /// The location of the current diagnostic that is in flight.
903  SourceLocation CurDiagLoc;
904 
905  /// The ID of the current diagnostic that is in flight.
906  ///
907  /// This is set to std::numeric_limits<unsigned>::max() when there is no
908  /// diagnostic in flight.
909  unsigned CurDiagID;
910 
911  enum {
912  /// The maximum number of arguments we can hold.
913  ///
914  /// We currently only support up to 10 arguments (%0-%9). A single
915  /// diagnostic with more than that almost certainly has to be simplified
916  /// anyway.
917  MaxArguments = 10,
918  };
919 
920  /// The number of entries in Arguments.
921  signed char NumDiagArgs;
922 
923  /// Specifies whether an argument is in DiagArgumentsStr or
924  /// in DiagArguments.
925  ///
926  /// This is an array of ArgumentKind::ArgumentKind enum values, one for each
927  /// argument.
928  unsigned char DiagArgumentsKind[MaxArguments];
929 
930  /// Holds the values of each string argument for the current
931  /// diagnostic.
932  ///
933  /// This is only used when the corresponding ArgumentKind is ak_std_string.
934  std::string DiagArgumentsStr[MaxArguments];
935 
936  /// The values for the various substitution positions.
937  ///
938  /// This is used when the argument is not an std::string. The specific
939  /// value is mangled into an intptr_t and the interpretation depends on
940  /// exactly what sort of argument kind it is.
941  intptr_t DiagArgumentsVal[MaxArguments];
942 
943  /// The list of ranges added to this diagnostic.
945 
946  /// If valid, provides a hint with some code to insert, remove,
947  /// or modify at a particular position.
948  SmallVector<FixItHint, 8> DiagFixItHints;
949 
950  DiagnosticMapping makeUserMapping(diag::Severity Map, SourceLocation L) {
951  bool isPragma = L.isValid();
952  DiagnosticMapping Mapping =
953  DiagnosticMapping::Make(Map, /*IsUser=*/true, isPragma);
954 
955  // If this is a pragma mapping, then set the diagnostic mapping flags so
956  // that we override command line options.
957  if (isPragma) {
958  Mapping.setNoWarningAsError(true);
959  Mapping.setNoErrorAsFatal(true);
960  }
961 
962  return Mapping;
963  }
964 
965  /// Used to report a diagnostic that is finally fully formed.
966  ///
967  /// \returns true if the diagnostic was emitted, false if it was suppressed.
968  bool ProcessDiag() {
969  return Diags->ProcessDiag(*this);
970  }
971 
972  /// @name Diagnostic Emission
973  /// @{
974 protected:
975  friend class ASTReader;
976  friend class ASTWriter;
977 
978  // Sema requires access to the following functions because the current design
979  // of SFINAE requires it to use its own SemaDiagnosticBuilder, which needs to
980  // access us directly to ensure we minimize the emitted code for the common
981  // Sema::Diag() patterns.
982  friend class Sema;
983 
984  /// Emit the current diagnostic and clear the diagnostic state.
985  ///
986  /// \param Force Emit the diagnostic regardless of suppression settings.
987  bool EmitCurrentDiagnostic(bool Force = false);
988 
989  unsigned getCurrentDiagID() const { return CurDiagID; }
990 
991  SourceLocation getCurrentDiagLoc() const { return CurDiagLoc; }
992 
993  /// @}
994 };
995 
996 /// RAII class that determines when any errors have occurred
997 /// between the time the instance was created and the time it was
998 /// queried.
1001  unsigned NumErrors;
1002  unsigned NumUnrecoverableErrors;
1003 
1004 public:
1006  : Diag(Diag) { reset(); }
1007 
1008  /// Determine whether any errors have occurred since this
1009  /// object instance was created.
1010  bool hasErrorOccurred() const {
1011  return Diag.TrapNumErrorsOccurred > NumErrors;
1012  }
1013 
1014  /// Determine whether any unrecoverable errors have occurred since this
1015  /// object instance was created.
1017  return Diag.TrapNumUnrecoverableErrorsOccurred > NumUnrecoverableErrors;
1018  }
1019 
1020  /// Set to initial state of "no errors occurred".
1021  void reset() {
1022  NumErrors = Diag.TrapNumErrorsOccurred;
1023  NumUnrecoverableErrors = Diag.TrapNumUnrecoverableErrorsOccurred;
1024  }
1025 };
1026 
1027 //===----------------------------------------------------------------------===//
1028 // DiagnosticBuilder
1029 //===----------------------------------------------------------------------===//
1030 
1031 /// A little helper class used to produce diagnostics.
1032 ///
1033 /// This is constructed by the DiagnosticsEngine::Report method, and
1034 /// allows insertion of extra information (arguments and source ranges) into
1035 /// the currently "in flight" diagnostic. When the temporary for the builder
1036 /// is destroyed, the diagnostic is issued.
1037 ///
1038 /// Note that many of these will be created as temporary objects (many call
1039 /// sites), so we want them to be small and we never want their address taken.
1040 /// This ensures that compilers with somewhat reasonable optimizers will promote
1041 /// the common fields to registers, eliminating increments of the NumArgs field,
1042 /// for example.
1044  friend class DiagnosticsEngine;
1045  friend class PartialDiagnostic;
1046 
1047  mutable DiagnosticsEngine *DiagObj = nullptr;
1048  mutable unsigned NumArgs = 0;
1049 
1050  /// Status variable indicating if this diagnostic is still active.
1051  ///
1052  // NOTE: This field is redundant with DiagObj (IsActive iff (DiagObj == 0)),
1053  // but LLVM is not currently smart enough to eliminate the null check that
1054  // Emit() would end up with if we used that as our status variable.
1055  mutable bool IsActive = false;
1056 
1057  /// Flag indicating that this diagnostic is being emitted via a
1058  /// call to ForceEmit.
1059  mutable bool IsForceEmit = false;
1060 
1061  DiagnosticBuilder() = default;
1062 
1063  explicit DiagnosticBuilder(DiagnosticsEngine *diagObj)
1064  : DiagObj(diagObj), IsActive(true) {
1065  assert(diagObj && "DiagnosticBuilder requires a valid DiagnosticsEngine!");
1066  diagObj->DiagRanges.clear();
1067  diagObj->DiagFixItHints.clear();
1068  }
1069 
1070 protected:
1071  void FlushCounts() {
1072  DiagObj->NumDiagArgs = NumArgs;
1073  }
1074 
1075  /// Clear out the current diagnostic.
1076  void Clear() const {
1077  DiagObj = nullptr;
1078  IsActive = false;
1079  IsForceEmit = false;
1080  }
1081 
1082  /// Determine whether this diagnostic is still active.
1083  bool isActive() const { return IsActive; }
1084 
1085  /// Force the diagnostic builder to emit the diagnostic now.
1086  ///
1087  /// Once this function has been called, the DiagnosticBuilder object
1088  /// should not be used again before it is destroyed.
1089  ///
1090  /// \returns true if a diagnostic was emitted, false if the
1091  /// diagnostic was suppressed.
1092  bool Emit() {
1093  // If this diagnostic is inactive, then its soul was stolen by the copy ctor
1094  // (or by a subclass, as in SemaDiagnosticBuilder).
1095  if (!isActive()) return false;
1096 
1097  // When emitting diagnostics, we set the final argument count into
1098  // the DiagnosticsEngine object.
1099  FlushCounts();
1100 
1101  // Process the diagnostic.
1102  bool Result = DiagObj->EmitCurrentDiagnostic(IsForceEmit);
1103 
1104  // This diagnostic is dead.
1105  Clear();
1106 
1107  return Result;
1108  }
1109 
1110 public:
1111  /// Copy constructor. When copied, this "takes" the diagnostic info from the
1112  /// input and neuters it.
1114  DiagObj = D.DiagObj;
1115  IsActive = D.IsActive;
1116  IsForceEmit = D.IsForceEmit;
1117  D.Clear();
1118  NumArgs = D.NumArgs;
1119  }
1120 
1121  DiagnosticBuilder &operator=(const DiagnosticBuilder &) = delete;
1122 
1123  /// Emits the diagnostic.
1125  Emit();
1126  }
1127 
1128  /// Forces the diagnostic to be emitted.
1130  IsForceEmit = true;
1131  return *this;
1132  }
1133 
1134  /// Conversion of DiagnosticBuilder to bool always returns \c true.
1135  ///
1136  /// This allows is to be used in boolean error contexts (where \c true is
1137  /// used to indicate that an error has occurred), like:
1138  /// \code
1139  /// return Diag(...);
1140  /// \endcode
1141  operator bool() const { return true; }
1142 
1143  void AddString(StringRef S) const {
1144  assert(isActive() && "Clients must not add to cleared diagnostic!");
1145  assert(NumArgs < DiagnosticsEngine::MaxArguments &&
1146  "Too many arguments to diagnostic!");
1147  DiagObj->DiagArgumentsKind[NumArgs] = DiagnosticsEngine::ak_std_string;
1148  DiagObj->DiagArgumentsStr[NumArgs++] = S;
1149  }
1150 
1152  assert(isActive() && "Clients must not add to cleared diagnostic!");
1153  assert(NumArgs < DiagnosticsEngine::MaxArguments &&
1154  "Too many arguments to diagnostic!");
1155  DiagObj->DiagArgumentsKind[NumArgs] = Kind;
1156  DiagObj->DiagArgumentsVal[NumArgs++] = V;
1157  }
1158 
1159  void AddSourceRange(const CharSourceRange &R) const {
1160  assert(isActive() && "Clients must not add to cleared diagnostic!");
1161  DiagObj->DiagRanges.push_back(R);
1162  }
1163 
1164  void AddFixItHint(const FixItHint &Hint) const {
1165  assert(isActive() && "Clients must not add to cleared diagnostic!");
1166  if (!Hint.isNull())
1167  DiagObj->DiagFixItHints.push_back(Hint);
1168  }
1169 
1170  void addFlagValue(StringRef V) const { DiagObj->FlagValue = V; }
1171 };
1172 
1174  StringRef Val;
1175 
1176  explicit AddFlagValue(StringRef V) : Val(V) {}
1177 };
1178 
1179 /// Register a value for the flag in the current diagnostic. This
1180 /// value will be shown as the suffix "=value" after the flag name. It is
1181 /// useful in cases where the diagnostic flag accepts values (e.g.,
1182 /// -Rpass or -Wframe-larger-than).
1184  const AddFlagValue V) {
1185  DB.addFlagValue(V.Val);
1186  return DB;
1187 }
1188 
1190  StringRef S) {
1191  DB.AddString(S);
1192  return DB;
1193 }
1194 
1196  const char *Str) {
1197  DB.AddTaggedVal(reinterpret_cast<intptr_t>(Str),
1199  return DB;
1200 }
1201 
1202 inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB, int I) {
1204  return DB;
1205 }
1206 
1207 // We use enable_if here to prevent that this overload is selected for
1208 // pointers or other arguments that are implicitly convertible to bool.
1209 template <typename T>
1210 inline
1211 typename std::enable_if<std::is_same<T, bool>::value,
1212  const DiagnosticBuilder &>::type
1215  return DB;
1216 }
1217 
1219  unsigned I) {
1221  return DB;
1222 }
1223 
1225  tok::TokenKind I) {
1226  DB.AddTaggedVal(static_cast<unsigned>(I), DiagnosticsEngine::ak_tokenkind);
1227  return DB;
1228 }
1229 
1231  const IdentifierInfo *II) {
1232  DB.AddTaggedVal(reinterpret_cast<intptr_t>(II),
1234  return DB;
1235 }
1236 
1237 // Adds a DeclContext to the diagnostic. The enable_if template magic is here
1238 // so that we only match those arguments that are (statically) DeclContexts;
1239 // other arguments that derive from DeclContext (e.g., RecordDecls) will not
1240 // match.
1241 template <typename T>
1242 inline typename std::enable_if<
1244  const DiagnosticBuilder &>::type
1245 operator<<(const DiagnosticBuilder &DB, T *DC) {
1246  DB.AddTaggedVal(reinterpret_cast<intptr_t>(DC),
1248  return DB;
1249 }
1250 
1252  SourceRange R) {
1254  return DB;
1255 }
1256 
1258  ArrayRef<SourceRange> Ranges) {
1259  for (SourceRange R : Ranges)
1261  return DB;
1262 }
1263 
1265  const CharSourceRange &R) {
1266  DB.AddSourceRange(R);
1267  return DB;
1268 }
1269 
1271  const FixItHint &Hint) {
1272  DB.AddFixItHint(Hint);
1273  return DB;
1274 }
1275 
1277  ArrayRef<FixItHint> Hints) {
1278  for (const FixItHint &Hint : Hints)
1279  DB.AddFixItHint(Hint);
1280  return DB;
1281 }
1282 
1283 /// A nullability kind paired with a bit indicating whether it used a
1284 /// context-sensitive keyword.
1285 using DiagNullabilityKind = std::pair<NullabilityKind, bool>;
1286 
1288  DiagNullabilityKind nullability);
1289 
1291  unsigned DiagID) {
1292  assert(CurDiagID == std::numeric_limits<unsigned>::max() &&
1293  "Multiple diagnostics in flight at once!");
1294  CurDiagLoc = Loc;
1295  CurDiagID = DiagID;
1296  FlagValue.clear();
1297  return DiagnosticBuilder(this);
1298 }
1299 
1301  llvm::Error &&E) {
1302  DB.AddString(toString(std::move(E)));
1303  return DB;
1304 }
1305 
1307  return Report(SourceLocation(), DiagID);
1308 }
1309 
1310 //===----------------------------------------------------------------------===//
1311 // Diagnostic
1312 //===----------------------------------------------------------------------===//
1313 
1314 /// A little helper class (which is basically a smart pointer that forwards
1315 /// info from DiagnosticsEngine) that allows clients to enquire about the
1316 /// currently in-flight diagnostic.
1317 class Diagnostic {
1318  const DiagnosticsEngine *DiagObj;
1319  StringRef StoredDiagMessage;
1320 
1321 public:
1322  explicit Diagnostic(const DiagnosticsEngine *DO) : DiagObj(DO) {}
1323  Diagnostic(const DiagnosticsEngine *DO, StringRef storedDiagMessage)
1324  : DiagObj(DO), StoredDiagMessage(storedDiagMessage) {}
1325 
1326  const DiagnosticsEngine *getDiags() const { return DiagObj; }
1327  unsigned getID() const { return DiagObj->CurDiagID; }
1328  const SourceLocation &getLocation() const { return DiagObj->CurDiagLoc; }
1329  bool hasSourceManager() const { return DiagObj->hasSourceManager(); }
1330  SourceManager &getSourceManager() const { return DiagObj->getSourceManager();}
1331 
1332  unsigned getNumArgs() const { return DiagObj->NumDiagArgs; }
1333 
1334  /// Return the kind of the specified index.
1335  ///
1336  /// Based on the kind of argument, the accessors below can be used to get
1337  /// the value.
1338  ///
1339  /// \pre Idx < getNumArgs()
1341  assert(Idx < getNumArgs() && "Argument index out of range!");
1342  return (DiagnosticsEngine::ArgumentKind)DiagObj->DiagArgumentsKind[Idx];
1343  }
1344 
1345  /// Return the provided argument string specified by \p Idx.
1346  /// \pre getArgKind(Idx) == DiagnosticsEngine::ak_std_string
1347  const std::string &getArgStdStr(unsigned Idx) const {
1348  assert(getArgKind(Idx) == DiagnosticsEngine::ak_std_string &&
1349  "invalid argument accessor!");
1350  return DiagObj->DiagArgumentsStr[Idx];
1351  }
1352 
1353  /// Return the specified C string argument.
1354  /// \pre getArgKind(Idx) == DiagnosticsEngine::ak_c_string
1355  const char *getArgCStr(unsigned Idx) const {
1356  assert(getArgKind(Idx) == DiagnosticsEngine::ak_c_string &&
1357  "invalid argument accessor!");
1358  return reinterpret_cast<const char*>(DiagObj->DiagArgumentsVal[Idx]);
1359  }
1360 
1361  /// Return the specified signed integer argument.
1362  /// \pre getArgKind(Idx) == DiagnosticsEngine::ak_sint
1363  int getArgSInt(unsigned Idx) const {
1364  assert(getArgKind(Idx) == DiagnosticsEngine::ak_sint &&
1365  "invalid argument accessor!");
1366  return (int)DiagObj->DiagArgumentsVal[Idx];
1367  }
1368 
1369  /// Return the specified unsigned integer argument.
1370  /// \pre getArgKind(Idx) == DiagnosticsEngine::ak_uint
1371  unsigned getArgUInt(unsigned Idx) const {
1372  assert(getArgKind(Idx) == DiagnosticsEngine::ak_uint &&
1373  "invalid argument accessor!");
1374  return (unsigned)DiagObj->DiagArgumentsVal[Idx];
1375  }
1376 
1377  /// Return the specified IdentifierInfo argument.
1378  /// \pre getArgKind(Idx) == DiagnosticsEngine::ak_identifierinfo
1379  const IdentifierInfo *getArgIdentifier(unsigned Idx) const {
1380  assert(getArgKind(Idx) == DiagnosticsEngine::ak_identifierinfo &&
1381  "invalid argument accessor!");
1382  return reinterpret_cast<IdentifierInfo*>(DiagObj->DiagArgumentsVal[Idx]);
1383  }
1384 
1385  /// Return the specified non-string argument in an opaque form.
1386  /// \pre getArgKind(Idx) != DiagnosticsEngine::ak_std_string
1387  intptr_t getRawArg(unsigned Idx) const {
1388  assert(getArgKind(Idx) != DiagnosticsEngine::ak_std_string &&
1389  "invalid argument accessor!");
1390  return DiagObj->DiagArgumentsVal[Idx];
1391  }
1392 
1393  /// Return the number of source ranges associated with this diagnostic.
1394  unsigned getNumRanges() const {
1395  return DiagObj->DiagRanges.size();
1396  }
1397 
1398  /// \pre Idx < getNumRanges()
1399  const CharSourceRange &getRange(unsigned Idx) const {
1400  assert(Idx < getNumRanges() && "Invalid diagnostic range index!");
1401  return DiagObj->DiagRanges[Idx];
1402  }
1403 
1404  /// Return an array reference for this diagnostic's ranges.
1406  return DiagObj->DiagRanges;
1407  }
1408 
1409  unsigned getNumFixItHints() const {
1410  return DiagObj->DiagFixItHints.size();
1411  }
1412 
1413  const FixItHint &getFixItHint(unsigned Idx) const {
1414  assert(Idx < getNumFixItHints() && "Invalid index!");
1415  return DiagObj->DiagFixItHints[Idx];
1416  }
1417 
1419  return DiagObj->DiagFixItHints;
1420  }
1421 
1422  /// Format this diagnostic into a string, substituting the
1423  /// formal arguments into the %0 slots.
1424  ///
1425  /// The result is appended onto the \p OutStr array.
1426  void FormatDiagnostic(SmallVectorImpl<char> &OutStr) const;
1427 
1428  /// Format the given format-string into the output buffer using the
1429  /// arguments stored in this diagnostic.
1430  void FormatDiagnostic(const char *DiagStr, const char *DiagEnd,
1431  SmallVectorImpl<char> &OutStr) const;
1432 };
1433 
1434 /**
1435  * Represents a diagnostic in a form that can be retained until its
1436  * corresponding source manager is destroyed.
1437  */
1439  unsigned ID;
1441  FullSourceLoc Loc;
1442  std::string Message;
1443  std::vector<CharSourceRange> Ranges;
1444  std::vector<FixItHint> FixIts;
1445 
1446 public:
1447  StoredDiagnostic() = default;
1449  StoredDiagnostic(DiagnosticsEngine::Level Level, unsigned ID,
1450  StringRef Message);
1451  StoredDiagnostic(DiagnosticsEngine::Level Level, unsigned ID,
1452  StringRef Message, FullSourceLoc Loc,
1454  ArrayRef<FixItHint> Fixits);
1455 
1456  /// Evaluates true when this object stores a diagnostic.
1457  explicit operator bool() const { return !Message.empty(); }
1458 
1459  unsigned getID() const { return ID; }
1461  const FullSourceLoc &getLocation() const { return Loc; }
1462  StringRef getMessage() const { return Message; }
1463 
1464  void setLocation(FullSourceLoc Loc) { this->Loc = Loc; }
1465 
1466  using range_iterator = std::vector<CharSourceRange>::const_iterator;
1467 
1468  range_iterator range_begin() const { return Ranges.begin(); }
1469  range_iterator range_end() const { return Ranges.end(); }
1470  unsigned range_size() const { return Ranges.size(); }
1471 
1473  return llvm::makeArrayRef(Ranges);
1474  }
1475 
1476  using fixit_iterator = std::vector<FixItHint>::const_iterator;
1477 
1478  fixit_iterator fixit_begin() const { return FixIts.begin(); }
1479  fixit_iterator fixit_end() const { return FixIts.end(); }
1480  unsigned fixit_size() const { return FixIts.size(); }
1481 
1483  return llvm::makeArrayRef(FixIts);
1484  }
1485 };
1486 
1487 /// Abstract interface, implemented by clients of the front-end, which
1488 /// formats and prints fully processed diagnostics.
1490 protected:
1491  unsigned NumWarnings = 0; ///< Number of warnings reported
1492  unsigned NumErrors = 0; ///< Number of errors reported
1493 
1494 public:
1495  DiagnosticConsumer() = default;
1496  virtual ~DiagnosticConsumer();
1497 
1498  unsigned getNumErrors() const { return NumErrors; }
1499  unsigned getNumWarnings() const { return NumWarnings; }
1500  virtual void clear() { NumWarnings = NumErrors = 0; }
1501 
1502  /// Callback to inform the diagnostic client that processing
1503  /// of a source file is beginning.
1504  ///
1505  /// Note that diagnostics may be emitted outside the processing of a source
1506  /// file, for example during the parsing of command line options. However,
1507  /// diagnostics with source range information are required to only be emitted
1508  /// in between BeginSourceFile() and EndSourceFile().
1509  ///
1510  /// \param LangOpts The language options for the source file being processed.
1511  /// \param PP The preprocessor object being used for the source; this is
1512  /// optional, e.g., it may not be present when processing AST source files.
1513  virtual void BeginSourceFile(const LangOptions &LangOpts,
1514  const Preprocessor *PP = nullptr) {}
1515 
1516  /// Callback to inform the diagnostic client that processing
1517  /// of a source file has ended.
1518  ///
1519  /// The diagnostic client should assume that any objects made available via
1520  /// BeginSourceFile() are inaccessible.
1521  virtual void EndSourceFile() {}
1522 
1523  /// Callback to inform the diagnostic client that processing of all
1524  /// source files has ended.
1525  virtual void finish() {}
1526 
1527  /// Indicates whether the diagnostics handled by this
1528  /// DiagnosticConsumer should be included in the number of diagnostics
1529  /// reported by DiagnosticsEngine.
1530  ///
1531  /// The default implementation returns true.
1532  virtual bool IncludeInDiagnosticCounts() const;
1533 
1534  /// Handle this diagnostic, reporting it to the user or
1535  /// capturing it to a log as needed.
1536  ///
1537  /// The default implementation just keeps track of the total number of
1538  /// warnings and errors.
1539  virtual void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
1540  const Diagnostic &Info);
1541 };
1542 
1543 /// A diagnostic client that ignores all diagnostics.
1545  virtual void anchor();
1546 
1547  void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
1548  const Diagnostic &Info) override {
1549  // Just ignore it.
1550  }
1551 };
1552 
1553 /// Diagnostic consumer that forwards diagnostics along to an
1554 /// existing, already-initialized diagnostic consumer.
1555 ///
1558 
1559 public:
1561  ~ForwardingDiagnosticConsumer() override;
1562 
1563  void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
1564  const Diagnostic &Info) override;
1565  void clear() override;
1566 
1567  bool IncludeInDiagnosticCounts() const override;
1568 };
1569 
1570 // Struct used for sending info about how a type should be printed.
1574  unsigned PrintTree : 1;
1575  unsigned PrintFromType : 1;
1576  unsigned ElideType : 1;
1577  unsigned ShowColors : 1;
1578 
1579  // The printer sets this variable to true if the template diff was used.
1580  unsigned TemplateDiffUsed : 1;
1581 };
1582 
1583 /// Special character that the diagnostic printer will use to toggle the bold
1584 /// attribute. The character itself will be not be printed.
1585 const char ToggleHighlight = 127;
1586 
1587 /// ProcessWarningOptions - Initialize the diagnostic client and process the
1588 /// warning options specified on the command line.
1590  const DiagnosticOptions &Opts,
1591  bool ReportDiags = true);
1592 
1593 } // namespace clang
1594 
1595 #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:1459
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:747
DiagnosticConsumer * getClient()
Definition: Diagnostic.h:510
unsigned fixit_size() const
Definition: Diagnostic.h:1480
fixit_iterator fixit_end() const
Definition: Diagnostic.h:1479
void AddFixItHint(const FixItHint &Hint) const
Definition: Diagnostic.h:1164
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:1468
static CharSourceRange getTokenRange(SourceRange R)
void setShowOverloads(OverloadsShown Val)
Specify which overload candidates to show when overload resolution fails.
Definition: Diagnostic.h:657
~DiagnosticBuilder()
Emits the diagnostic.
Definition: Diagnostic.h:1124
Represents a diagnostic in a form that can be retained until its corresponding source manager is dest...
Definition: Diagnostic.h:1438
const DiagnosticBuilder & operator<<(const DiagnosticBuilder &DB, const Attr *At)
Definition: Attr.h:334
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:1129
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1290
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:1340
unsigned range_size() const
Definition: Diagnostic.h:1470
range_iterator range_end() const
Definition: Diagnostic.h:1469
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:688
const std::string & getArgStdStr(unsigned Idx) const
Return the provided argument string specified by Idx.
Definition: Diagnostic.h:1347
virtual void EndSourceFile()
Callback to inform the diagnostic client that processing of a source file has ended.
Definition: Diagnostic.h:1521
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:1489
RAII class that determines when any errors have occurred between the time the instance was created an...
Definition: Diagnostic.h:999
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:1329
unsigned getID() const
Definition: Diagnostic.h:1327
const DiagnosticsEngine * getDiags() const
Definition: Diagnostic.h:1326
void AddTaggedVal(intptr_t V, DiagnosticsEngine::ArgumentKind Kind) const
Definition: Diagnostic.h:1151
One of these records is kept for each identifier that is lexed.
unsigned getCurrentDiagID() const
Definition: Diagnostic.h:989
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:696
void setElideType(bool Val)
Set type eliding, to skip outputting same types occurring in template types.
Definition: Diagnostic.h:640
unsigned getNumErrors() const
Definition: Diagnostic.h:1498
const FixItHint & getFixItHint(unsigned Idx) const
Definition: Diagnostic.h:1413
void setExtensionHandlingBehavior(diag::Severity H)
Controls whether otherwise-unmapped extension diagnostics are mapped onto ignore/warning/error.
Definition: Diagnostic.h:685
bool isNull() const
Definition: Diagnostic.h:86
ForwardingDiagnosticConsumer(DiagnosticConsumer &Target)
Definition: Diagnostic.h:1560
__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
void setSourceManager(SourceManager *SrcMgr)
Definition: Diagnostic.h:527
unsigned getArgUInt(unsigned Idx) const
Return the specified unsigned integer argument.
Definition: Diagnostic.h:1371
bool isActive() const
Determine whether this diagnostic is still active.
Definition: Diagnostic.h:1083
StringRef getFlagValue() const
Return the value associated with this diagnostic flag.
Definition: Diagnostic.h:884
const SourceLocation & getLocation() const
Definition: Diagnostic.h:1328
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:757
bool isDiagnosticInFlight() const
Determine whethere there is already a diagnostic in flight.
Definition: Diagnostic.h:852
intptr_t getRawArg(unsigned Idx) const
Return the specified non-string argument in an opaque form.
Definition: Diagnostic.h:1387
ArrayRef< CharSourceRange > getRanges() const
Definition: Diagnostic.h:1472
llvm::Error Error
DiagnosticBuilder(const DiagnosticBuilder &D)
Copy constructor.
Definition: Diagnostic.h:1113
SourceLocation getCurrentDiagLoc() const
Definition: Diagnostic.h:991
StringRef getMessage() const
Definition: Diagnostic.h:1462
Diagnostic(const DiagnosticsEngine *DO, StringRef storedDiagMessage)
Definition: Diagnostic.h:1323
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:1043
unsigned Offset
Definition: Format.cpp:1758
Represents a character-granular source range.
DiagnosticsEngine::Level getLevel() const
Definition: Diagnostic.h:1460
DiagnosticErrorTrap(DiagnosticsEngine &Diag)
Definition: Diagnostic.h:1005
bool hasUncompilableErrorOccurred() const
Errors that actually prevent compilation, not those that are upgraded from a warning by -Werror...
Definition: Diagnostic.h:751
unsigned getNumRanges() const
Return the number of source ranges associated with this diagnostic.
Definition: Diagnostic.h:1394
ArrayRef< FixItHint > getFixIts() const
Definition: Diagnostic.h:1482
void addFlagValue(StringRef V) const
Definition: Diagnostic.h:1170
#define V(N, I)
Definition: ASTContext.h:2913
const char * getArgCStr(unsigned Idx) const
Return the specified C string argument.
Definition: Diagnostic.h:1355
#define bool
Definition: stdbool.h:15
const IdentifierInfo * getArgIdentifier(unsigned Idx) const
Return the specified IdentifierInfo argument.
Definition: Diagnostic.h:1379
AddFlagValue(StringRef V)
Definition: Diagnostic.h:1176
void Clear()
Clear out the current diagnostic.
Definition: Diagnostic.h:881
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:1478
OverloadsShown getShowOverloads() const
Definition: Diagnostic.h:660
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:761
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:1159
__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:1076
const CharSourceRange & getRange(unsigned Idx) const
Definition: Diagnostic.h:1399
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:1010
bool isLastDiagnosticIgnored() const
Determine whether the previous diagnostic was ignored.
Definition: Diagnostic.h:677
std::pair< NullabilityKind, bool > DiagNullabilityKind
A nullability kind paired with a bit indicating whether it used a context-sensitive keyword...
Definition: Diagnostic.h:1285
unsigned getNumWarnings() const
Definition: Diagnostic.h:1499
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:1525
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:783
const char ToggleHighlight
Special character that the diagnostic printer will use to toggle the bold attribute.
Definition: Diagnostic.h:1585
Diagnostic consumer that forwards diagnostics along to an existing, already-initialized diagnostic co...
Definition: Diagnostic.h:1556
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:1021
void AddString(StringRef S) const
Definition: Diagnostic.h:1143
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:792
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:1330
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
Definition: Diagnostic.h:776
void setNumWarnings(unsigned NumWarnings)
Definition: Diagnostic.h:763
static DiagnosticMapping Make(diag::Severity Severity, bool IsUser, bool IsPragma)
void setLastDiagnosticIgnored(bool Ignored)
Pretend that the last diagnostic issued was ignored, so any subsequent notes will be suppressed...
Definition: Diagnostic.h:668
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:1476
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:1544
Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const
Based on the way the client configured the DiagnosticsEngine object, classify the specified diagnosti...
Definition: Diagnostic.h:834
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:1461
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:1016
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 setPrintTemplateTree(bool Val)
Set tree printing, to outputting the template difference in a tree format.
Definition: Diagnostic.h:645
void setShowColors(bool Val)
Set color printing, so the type diffing will inject color markers into the output.
Definition: Diagnostic.h:650
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:1409
void setConstexprBacktraceLimit(unsigned Limit)
Specify the maximum number of constexpr evaluation notes to emit along with a given diagnostic...
Definition: Diagnostic.h:575
void setSuppressAllDiagnostics(bool Val)
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 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:1322
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:754
llvm::iterator_range< DiagState::const_iterator > diag_mapping_range
Definition: Diagnostic.h:502
void DecrementAllExtensionsSilenced()
Definition: Diagnostic.h:697
int getArgSInt(unsigned Idx) const
Return the specified signed integer argument.
Definition: Diagnostic.h:1363
const IntrusiveRefCntPtr< DiagnosticIDs > & getDiagnosticIDs() const
Definition: Diagnostic.h:495
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:1405
ArrayRef< FixItHint > getFixItHints() const
Definition: Diagnostic.h:1418
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:1332
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1317
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:819
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:1092
#define true
Definition: stdbool.h:16
A trivial tuple used to represent a source range.
void setLocation(FullSourceLoc Loc)
Definition: Diagnostic.h:1464
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:1513
std::vector< CharSourceRange >::const_iterator range_iterator
Definition: Diagnostic.h:1466
This class handles loading and caching of source files into memory.
bool getSuppressAllDiagnostics() const
Definition: Diagnostic.h:636
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:125
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:799