clang  16.0.0git
BugReporter.h
Go to the documentation of this file.
1 //===- BugReporter.h - Generate PathDiagnostics -----------------*- 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 // This file defines BugReporter, a utility class for generating
10 // PathDiagnostics for analyses based on ProgramState.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_BUGREPORTER_H
15 #define LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_BUGREPORTER_H
16 
18 #include "clang/Basic/LLVM.h"
20 #include "clang/Lex/Preprocessor.h"
28 #include "llvm/ADT/ArrayRef.h"
29 #include "llvm/ADT/DenseSet.h"
30 #include "llvm/ADT/FoldingSet.h"
31 #include "llvm/ADT/ImmutableSet.h"
32 #include "llvm/ADT/None.h"
33 #include "llvm/ADT/SmallSet.h"
34 #include "llvm/ADT/SmallVector.h"
35 #include "llvm/ADT/StringMap.h"
36 #include "llvm/ADT/StringRef.h"
37 #include "llvm/ADT/ilist.h"
38 #include "llvm/ADT/ilist_node.h"
39 #include "llvm/ADT/iterator_range.h"
40 #include <cassert>
41 #include <memory>
42 #include <string>
43 #include <utility>
44 #include <vector>
45 
46 namespace clang {
47 
48 class AnalyzerOptions;
49 class ASTContext;
50 class Decl;
51 class LocationContext;
52 class SourceManager;
53 class Stmt;
54 
55 namespace ento {
56 
57 class BugType;
58 class CheckerBase;
59 class ExplodedGraph;
60 class ExplodedNode;
61 class ExprEngine;
62 class MemRegion;
63 
64 //===----------------------------------------------------------------------===//
65 // Interface for individual bug reports.
66 //===----------------------------------------------------------------------===//
67 
68 /// A mapping from diagnostic consumers to the diagnostics they should
69 /// consume.
71  llvm::DenseMap<PathDiagnosticConsumer *, std::unique_ptr<PathDiagnostic>>;
72 
73 /// Interface for classes constructing Stack hints.
74 ///
75 /// If a PathDiagnosticEvent occurs in a different frame than the final
76 /// diagnostic the hints can be used to summarize the effect of the call.
78 public:
79  virtual ~StackHintGenerator() = 0;
80 
81  /// Construct the Diagnostic message for the given ExplodedNode.
82  virtual std::string getMessage(const ExplodedNode *N) = 0;
83 };
84 
85 /// Constructs a Stack hint for the given symbol.
86 ///
87 /// The class knows how to construct the stack hint message based on
88 /// traversing the CallExpr associated with the call and checking if the given
89 /// symbol is returned or is one of the arguments.
90 /// The hint can be customized by redefining 'getMessageForX()' methods.
92 private:
93  SymbolRef Sym;
94  std::string Msg;
95 
96 public:
97  StackHintGeneratorForSymbol(SymbolRef S, StringRef M) : Sym(S), Msg(M) {}
98  ~StackHintGeneratorForSymbol() override = default;
99 
100  /// Search the call expression for the symbol Sym and dispatch the
101  /// 'getMessageForX()' methods to construct a specific message.
102  std::string getMessage(const ExplodedNode *N) override;
103 
104  /// Produces the message of the following form:
105  /// 'Msg via Nth parameter'
106  virtual std::string getMessageForArg(const Expr *ArgE, unsigned ArgIndex);
107 
109  return Msg;
110  }
111 
113  return Msg;
114  }
115 };
116 
117 /// This class provides an interface through which checkers can create
118 /// individual bug reports.
119 class BugReport {
120 public:
121  enum class Kind { Basic, PathSensitive };
122 
123 protected:
124  friend class BugReportEquivClass;
125  friend class BugReporter;
126 
128  const BugType& BT;
131 
135 
136  BugReport(Kind kind, const BugType &bt, StringRef desc)
137  : BugReport(kind, bt, "", desc) {}
138 
140  StringRef Description)
143 
144 public:
145  virtual ~BugReport() = default;
146 
147  Kind getKind() const { return K; }
148 
149  const BugType& getBugType() const { return BT; }
150 
151  /// A verbose warning message that is appropriate for displaying next to
152  /// the source code that introduces the problem. The description should be
153  /// at least a full sentence starting with a capital letter. The period at
154  /// the end of the warning is traditionally omitted. If the description
155  /// consists of multiple sentences, periods between the sentences are
156  /// encouraged, but the period at the end of the description is still omitted.
157  StringRef getDescription() const { return Description; }
158 
159  /// A short general warning message that is appropriate for displaying in
160  /// the list of all reported bugs. It should describe what kind of bug is found
161  /// but does not need to try to go into details of that specific bug.
162  /// Grammatical conventions of getDescription() apply here as well.
163  StringRef getShortDescription(bool UseFallback = true) const {
164  if (ShortDescription.empty() && UseFallback)
165  return Description;
166  return ShortDescription;
167  }
168 
169  /// The primary location of the bug report that points at the undesirable
170  /// behavior in the code. UIs should attach the warning description to this
171  /// location. The warning description should describe the bad behavior
172  /// at this location.
173  virtual PathDiagnosticLocation getLocation() const = 0;
174 
175  /// The smallest declaration that contains the bug location.
176  /// This is purely cosmetic; the declaration can be displayed to the user
177  /// but it does not affect whether the report is emitted.
178  virtual const Decl *getDeclWithIssue() const = 0;
179 
180  /// Get the location on which the report should be uniqued. Two warnings are
181  /// considered to be equivalent whenever they have the same bug types,
182  /// descriptions, and uniqueing locations. Out of a class of equivalent
183  /// warnings only one gets displayed to the user. For most warnings the
184  /// uniqueing location coincides with their location, but sometimes
185  /// it makes sense to use different locations. For example, a leak
186  /// checker can place the warning at the location where the last reference
187  /// to the leaking resource is dropped but at the same time unique the warning
188  /// by where that resource is acquired (allocated).
189  virtual PathDiagnosticLocation getUniqueingLocation() const = 0;
190 
191  /// Get the declaration that corresponds to (usually contains) the uniqueing
192  /// location. This is not actively used for uniqueing, i.e. otherwise
193  /// identical reports that have different uniqueing decls will be considered
194  /// equivalent.
195  virtual const Decl *getUniqueingDecl() const = 0;
196 
197  /// Add new item to the list of additional notes that need to be attached to
198  /// this report. If the report is path-sensitive, these notes will not be
199  /// displayed as part of the execution path explanation, but will be displayed
200  /// separately. Use bug visitors if you need to add an extra path note.
201  void addNote(StringRef Msg, const PathDiagnosticLocation &Pos,
203  auto P = std::make_shared<PathDiagnosticNotePiece>(Pos, Msg);
204 
205  for (const auto &R : Ranges)
206  P->addRange(R);
207 
208  Notes.push_back(std::move(P));
209  }
210 
212  return Notes;
213  }
214 
215  /// Add a range to a bug report.
216  ///
217  /// Ranges are used to highlight regions of interest in the source code.
218  /// They should be at the same source code line as the BugReport location.
219  /// By default, the source range of the statement corresponding to the error
220  /// node will be used; add a single invalid range to specify absence of
221  /// ranges.
223  assert((R.isValid() || Ranges.empty()) && "Invalid range can only be used "
224  "to specify that the report does not have a range.");
225  Ranges.push_back(R);
226  }
227 
228  /// Get the SourceRanges associated with the report.
230  return Ranges;
231  }
232 
233  /// Add a fix-it hint to the bug report.
234  ///
235  /// Fix-it hints are the suggested edits to the code that would resolve
236  /// the problem explained by the bug report. Fix-it hints should be
237  /// as conservative as possible because it is not uncommon for the user
238  /// to blindly apply all fixits to their project. Note that it is very hard
239  /// to produce a good fix-it hint for most path-sensitive warnings.
240  void addFixItHint(const FixItHint &F) {
241  Fixits.push_back(F);
242  }
243 
245 
246  /// Reports are uniqued to ensure that we do not emit multiple diagnostics
247  /// for each bug.
248  virtual void Profile(llvm::FoldingSetNodeID& hash) const = 0;
249 };
250 
251 class BasicBugReport : public BugReport {
252  PathDiagnosticLocation Location;
253  const Decl *DeclWithIssue = nullptr;
254 
255 public:
256  BasicBugReport(const BugType &bt, StringRef desc, PathDiagnosticLocation l)
257  : BugReport(Kind::Basic, bt, desc), Location(l) {}
258 
259  static bool classof(const BugReport *R) {
260  return R->getKind() == Kind::Basic;
261  }
262 
264  assert(Location.isValid());
265  return Location;
266  }
267 
268  const Decl *getDeclWithIssue() const override {
269  return DeclWithIssue;
270  }
271 
273  return getLocation();
274  }
275 
276  const Decl *getUniqueingDecl() const override {
277  return getDeclWithIssue();
278  }
279 
280  /// Specifically set the Decl where an issue occurred. This isn't necessary
281  /// for BugReports that cover a path as it will be automatically inferred.
282  void setDeclWithIssue(const Decl *declWithIssue) {
283  DeclWithIssue = declWithIssue;
284  }
285 
286  void Profile(llvm::FoldingSetNodeID& hash) const override;
287 };
288 
290 public:
292  using visitor_iterator = VisitorList::iterator;
293  using visitor_range = llvm::iterator_range<visitor_iterator>;
294 
295 protected:
296  /// The ExplodedGraph node against which the report was thrown. It corresponds
297  /// to the end of the execution path that demonstrates the bug.
298  const ExplodedNode *ErrorNode = nullptr;
299 
300  /// The range that corresponds to ErrorNode's program point. It is usually
301  /// highlighted in the report.
303 
304  /// Profile to identify equivalent bug reports for error report coalescing.
305 
306  /// A (stack of) a set of symbols that are registered with this
307  /// report as being "interesting", and thus used to help decide which
308  /// diagnostics to include when constructing the final path diagnostic.
309  /// The stack is largely used by BugReporter when generating PathDiagnostics
310  /// for multiple PathDiagnosticConsumers.
311  llvm::DenseMap<SymbolRef, bugreporter::TrackingKind> InterestingSymbols;
312 
313  /// A (stack of) set of regions that are registered with this report as being
314  /// "interesting", and thus used to help decide which diagnostics
315  /// to include when constructing the final path diagnostic.
316  /// The stack is largely used by BugReporter when generating PathDiagnostics
317  /// for multiple PathDiagnosticConsumers.
318  llvm::DenseMap<const MemRegion *, bugreporter::TrackingKind>
320 
321  /// A set of location contexts that correspoind to call sites which should be
322  /// considered "interesting".
323  llvm::SmallSet<const LocationContext *, 2> InterestingLocationContexts;
324 
325  /// A set of custom visitors which generate "event" diagnostics at
326  /// interesting points in the path.
328 
329  /// Used for ensuring the visitors are only added once.
330  llvm::FoldingSet<BugReporterVisitor> CallbacksSet;
331 
332  /// When set, this flag disables all callstack pruning from a diagnostic
333  /// path. This is useful for some reports that want maximum fidelty
334  /// when reporting an issue.
335  bool DoNotPrunePath = false;
336 
337  /// Used to track unique reasons why a bug report might be invalid.
338  ///
339  /// \sa markInvalid
340  /// \sa removeInvalidation
341  using InvalidationRecord = std::pair<const void *, const void *>;
342 
343  /// If non-empty, this bug report is likely a false positive and should not be
344  /// shown to the user.
345  ///
346  /// \sa markInvalid
347  /// \sa removeInvalidation
348  llvm::SmallSet<InvalidationRecord, 4> Invalidations;
349 
350  /// Conditions we're already tracking.
351  llvm::SmallSet<const ExplodedNode *, 4> TrackedConditions;
352 
353  /// Reports with different uniqueing locations are considered to be different
354  /// for the purposes of deduplication.
357 
358  const Stmt *getStmt() const;
359 
360  /// If an event occurs in a different frame than the final diagnostic,
361  /// supply a message that will be used to construct an extra hint on the
362  /// returns from all the calls on the stack from this event to the final
363  /// diagnostic.
364  // FIXME: Allow shared_ptr keys in DenseMap?
365  std::map<PathDiagnosticPieceRef, std::unique_ptr<StackHintGenerator>>
367 
368 public:
369  PathSensitiveBugReport(const BugType &bt, StringRef desc,
370  const ExplodedNode *errorNode)
371  : PathSensitiveBugReport(bt, desc, desc, errorNode) {}
372 
373  PathSensitiveBugReport(const BugType &bt, StringRef shortDesc, StringRef desc,
374  const ExplodedNode *errorNode)
375  : PathSensitiveBugReport(bt, shortDesc, desc, errorNode,
376  /*LocationToUnique*/ {},
377  /*DeclToUnique*/ nullptr) {}
378 
379  /// Create a PathSensitiveBugReport with a custom uniqueing location.
380  ///
381  /// The reports that have the same report location, description, bug type, and
382  /// ranges are uniqued - only one of the equivalent reports will be presented
383  /// to the user. This method allows to rest the location which should be used
384  /// for uniquing reports. For example, memory leaks checker, could set this to
385  /// the allocation site, rather then the location where the bug is reported.
386  PathSensitiveBugReport(const BugType &bt, StringRef desc,
387  const ExplodedNode *errorNode,
388  PathDiagnosticLocation LocationToUnique,
389  const Decl *DeclToUnique)
390  : PathSensitiveBugReport(bt, desc, desc, errorNode, LocationToUnique,
391  DeclToUnique) {}
392 
393  PathSensitiveBugReport(const BugType &bt, StringRef shortDesc, StringRef desc,
394  const ExplodedNode *errorNode,
395  PathDiagnosticLocation LocationToUnique,
396  const Decl *DeclToUnique);
397 
398  static bool classof(const BugReport *R) {
399  return R->getKind() == Kind::PathSensitive;
400  }
401 
402  const ExplodedNode *getErrorNode() const { return ErrorNode; }
403 
404  /// Indicates whether or not any path pruning should take place
405  /// when generating a PathDiagnostic from this BugReport.
406  bool shouldPrunePath() const { return !DoNotPrunePath; }
407 
408  /// Disable all path pruning when generating a PathDiagnostic.
410 
411  /// Get the location on which the report should be uniqued.
413  return UniqueingLocation;
414  }
415 
416  /// Get the declaration containing the uniqueing location.
417  const Decl *getUniqueingDecl() const override {
418  return UniqueingDecl;
419  }
420 
421  const Decl *getDeclWithIssue() const override;
422 
423  ArrayRef<SourceRange> getRanges() const override;
424 
425  PathDiagnosticLocation getLocation() const override;
426 
427  /// Marks a symbol as interesting. Different kinds of interestingness will
428  /// be processed differently by visitors (e.g. if the tracking kind is
429  /// condition, will append "will be used as a condition" to the message).
432 
433  void markNotInteresting(SymbolRef sym);
434 
435  /// Marks a region as interesting. Different kinds of interestingness will
436  /// be processed differently by visitors (e.g. if the tracking kind is
437  /// condition, will append "will be used as a condition" to the message).
438  void markInteresting(
439  const MemRegion *R,
441 
442  void markNotInteresting(const MemRegion *R);
443 
444  /// Marks a symbolic value as interesting. Different kinds of interestingness
445  /// will be processed differently by visitors (e.g. if the tracking kind is
446  /// condition, will append "will be used as a condition" to the message).
449  void markInteresting(const LocationContext *LC);
450 
451  bool isInteresting(SymbolRef sym) const;
452  bool isInteresting(const MemRegion *R) const;
453  bool isInteresting(SVal V) const;
454  bool isInteresting(const LocationContext *LC) const;
455 
458 
460  getInterestingnessKind(const MemRegion *R) const;
461 
463 
464  /// Returns whether or not this report should be considered valid.
465  ///
466  /// Invalid reports are those that have been classified as likely false
467  /// positives after the fact.
468  bool isValid() const {
469  return Invalidations.empty();
470  }
471 
472  /// Marks the current report as invalid, meaning that it is probably a false
473  /// positive and should not be reported to the user.
474  ///
475  /// The \p Tag and \p Data arguments are intended to be opaque identifiers for
476  /// this particular invalidation, where \p Tag represents the visitor
477  /// responsible for invalidation, and \p Data represents the reason this
478  /// visitor decided to invalidate the bug report.
479  ///
480  /// \sa removeInvalidation
481  void markInvalid(const void *Tag, const void *Data) {
482  Invalidations.insert(std::make_pair(Tag, Data));
483  }
484 
485  /// Profile to identify equivalent bug reports for error report coalescing.
486  /// Reports are uniqued to ensure that we do not emit multiple diagnostics
487  /// for each bug.
488  void Profile(llvm::FoldingSetNodeID &hash) const override;
489 
490  /// Add custom or predefined bug report visitors to this report.
491  ///
492  /// The visitors should be used when the default trace is not sufficient.
493  /// For example, they allow constructing a more elaborate trace.
494  /// @{
495  void addVisitor(std::unique_ptr<BugReporterVisitor> visitor);
496 
497  template <class VisitorType, class... Args>
498  void addVisitor(Args &&... ConstructorArgs) {
499  addVisitor(
500  std::make_unique<VisitorType>(std::forward<Args>(ConstructorArgs)...));
501  }
502  /// @}
503 
504  /// Remove all visitors attached to this bug report.
505  void clearVisitors();
506 
507  /// Iterators through the custom diagnostic visitors.
511 
512  /// Notes that the condition of the CFGBlock associated with \p Cond is
513  /// being tracked.
514  /// \returns false if the condition is already being tracked.
515  bool addTrackedCondition(const ExplodedNode *Cond) {
516  return TrackedConditions.insert(Cond).second;
517  }
518 
520  std::unique_ptr<StackHintGenerator> StackHint) {
521  StackHints[Piece] = std::move(StackHint);
522  }
523 
525  return StackHints.count(Piece) > 0;
526  }
527 
528  /// Produce the hint for the given node. The node contains
529  /// information about the call for which the diagnostic can be generated.
532  const ExplodedNode *N) const {
533  auto I = StackHints.find(Piece);
534  if (I != StackHints.end())
535  return I->second->getMessage(N);
536  return "";
537  }
538 };
539 
540 //===----------------------------------------------------------------------===//
541 // BugTypes (collections of related reports).
542 //===----------------------------------------------------------------------===//
543 
544 class BugReportEquivClass : public llvm::FoldingSetNode {
545  friend class BugReporter;
546 
547  /// List of *owned* BugReport objects.
549 
550  void AddReport(std::unique_ptr<BugReport> &&R) {
551  Reports.push_back(std::move(R));
552  }
553 
554 public:
555  BugReportEquivClass(std::unique_ptr<BugReport> R) { AddReport(std::move(R)); }
556 
557  ArrayRef<std::unique_ptr<BugReport>> getReports() const { return Reports; }
558 
559  void Profile(llvm::FoldingSetNodeID& ID) const {
560  assert(!Reports.empty());
561  Reports.front()->Profile(ID);
562  }
563 };
564 
565 //===----------------------------------------------------------------------===//
566 // BugReporter and friends.
567 //===----------------------------------------------------------------------===//
568 
570 public:
571  virtual ~BugReporterData() = default;
572 
574  virtual ASTContext &getASTContext() = 0;
575  virtual SourceManager &getSourceManager() = 0;
576  virtual AnalyzerOptions &getAnalyzerOptions() = 0;
577  virtual Preprocessor &getPreprocessor() = 0;
578 };
579 
580 /// BugReporter is a utility class for generating PathDiagnostics for analysis.
581 /// It collects the BugReports and BugTypes and knows how to generate
582 /// and flush the corresponding diagnostics.
583 ///
584 /// The base class is used for generating path-insensitive
585 class BugReporter {
586 private:
587  BugReporterData& D;
588 
589  /// Generate and flush the diagnostics for the given bug report.
590  void FlushReport(BugReportEquivClass& EQ);
591 
592  /// The set of bug reports tracked by the BugReporter.
593  llvm::FoldingSet<BugReportEquivClass> EQClasses;
594 
595  /// A vector of BugReports for tracking the allocated pointers and cleanup.
596  std::vector<BugReportEquivClass *> EQClassesVector;
597 
598 public:
600  virtual ~BugReporter();
601 
602  /// Generate and flush diagnostics for all bug reports.
603  void FlushReports();
604 
606  return D.getPathDiagnosticConsumers();
607  }
608 
609  /// Iterator over the set of BugReports tracked by the BugReporter.
610  using EQClasses_iterator = llvm::FoldingSet<BugReportEquivClass>::iterator;
611  EQClasses_iterator EQClasses_begin() { return EQClasses.begin(); }
612  EQClasses_iterator EQClasses_end() { return EQClasses.end(); }
613 
615 
617 
619 
621 
622  /// Add the given report to the set of reports tracked by BugReporter.
623  ///
624  /// The reports are usually generated by the checkers. Further, they are
625  /// folded based on the profile value, which is done to coalesce similar
626  /// reports.
627  virtual void emitReport(std::unique_ptr<BugReport> R);
628 
629  void EmitBasicReport(const Decl *DeclWithIssue, const CheckerBase *Checker,
630  StringRef BugName, StringRef BugCategory,
631  StringRef BugStr, PathDiagnosticLocation Loc,
632  ArrayRef<SourceRange> Ranges = None,
633  ArrayRef<FixItHint> Fixits = None);
634 
635  void EmitBasicReport(const Decl *DeclWithIssue, CheckerNameRef CheckerName,
636  StringRef BugName, StringRef BugCategory,
637  StringRef BugStr, PathDiagnosticLocation Loc,
638  ArrayRef<SourceRange> Ranges = None,
639  ArrayRef<FixItHint> Fixits = None);
640 
641 private:
642  llvm::StringMap<std::unique_ptr<BugType>> StrBugTypes;
643 
644  /// Returns a BugType that is associated with the given name and
645  /// category.
646  BugType *getBugTypeForName(CheckerNameRef CheckerName, StringRef name,
647  StringRef category);
648 
649  virtual BugReport *
650  findReportInEquivalenceClass(BugReportEquivClass &eqClass,
651  SmallVectorImpl<BugReport *> &bugReports) {
652  return eqClass.getReports()[0].get();
653  }
654 
655 protected:
656  /// Generate the diagnostics for the given bug report.
657  virtual std::unique_ptr<DiagnosticForConsumerMapTy>
658  generateDiagnosticForConsumerMap(BugReport *exampleReport,
660  ArrayRef<BugReport *> bugReports);
661 };
662 
663 /// GRBugReporter is used for generating path-sensitive reports.
664 class PathSensitiveBugReporter final : public BugReporter {
665  ExprEngine& Eng;
666 
667  BugReport *findReportInEquivalenceClass(
668  BugReportEquivClass &eqClass,
669  SmallVectorImpl<BugReport *> &bugReports) override;
670 
671  /// Generate the diagnostics for the given bug report.
672  std::unique_ptr<DiagnosticForConsumerMapTy>
673  generateDiagnosticForConsumerMap(BugReport *exampleReport,
675  ArrayRef<BugReport *> bugReports) override;
676 public:
678  : BugReporter(d), Eng(eng) {}
679 
680  /// getGraph - Get the exploded graph created by the analysis engine
681  /// for the analyzed method or function.
682  const ExplodedGraph &getGraph() const;
683 
684  /// getStateManager - Return the state manager used by the analysis
685  /// engine.
687 
688  /// \p bugReports A set of bug reports within a *single* equivalence class
689  ///
690  /// \return A mapping from consumers to the corresponding diagnostics.
691  /// Iterates through the bug reports within a single equivalence class,
692  /// stops at a first non-invalidated report.
693  std::unique_ptr<DiagnosticForConsumerMapTy> generatePathDiagnostics(
696 
697  void emitReport(std::unique_ptr<BugReport> R) override;
698 };
699 
700 
703 
704  virtual void anchor();
705 
706 public:
708 
709  virtual ~BugReporterContext() = default;
710 
712 
714  return BR.getStateManager();
715  }
716 
718  return BR.getContext();
719  }
720 
722  return BR.getSourceManager();
723  }
724 
726  return BR.getAnalyzerOptions();
727  }
728 };
729 
730 /// The tag that carries some information with it.
731 ///
732 /// It can be valuable to produce tags with some bits of information and later
733 /// reuse them for a better diagnostic.
734 ///
735 /// Please make sure that derived class' constuctor is private and that the user
736 /// can only create objects using DataTag::Factory. This also means that
737 /// DataTag::Factory should be friend for every derived class.
738 class DataTag : public ProgramPointTag {
739 public:
740  StringRef getTagDescription() const override { return "Data Tag"; }
741 
742  // Manage memory for DataTag objects.
743  class Factory {
744  std::vector<std::unique_ptr<DataTag>> Tags;
745 
746  public:
747  template <class DataTagType, class... Args>
748  const DataTagType *make(Args &&... ConstructorArgs) {
749  // We cannot use std::make_unique because we cannot access the private
750  // constructor from inside it.
751  Tags.emplace_back(
752  new DataTagType(std::forward<Args>(ConstructorArgs)...));
753  return static_cast<DataTagType *>(Tags.back().get());
754  }
755  };
756 
757 protected:
758  DataTag(void *TagKind) : ProgramPointTag(TagKind) {}
759 };
760 
761 /// The tag upon which the TagVisitor reacts. Add these in order to display
762 /// additional PathDiagnosticEventPieces along the path.
763 class NoteTag : public DataTag {
764 public:
765  using Callback = std::function<std::string(BugReporterContext &,
767 
768 private:
769  static int Kind;
770 
771  const Callback Cb;
772  const bool IsPrunable;
773 
774  NoteTag(Callback &&Cb, bool IsPrunable)
775  : DataTag(&Kind), Cb(std::move(Cb)), IsPrunable(IsPrunable) {}
776 
777 public:
778  static bool classof(const ProgramPointTag *T) {
779  return T->getTagKind() == &Kind;
780  }
781 
783  PathSensitiveBugReport &R) const {
784  std::string Msg = Cb(BRC, R);
785  if (Msg.empty())
786  return None;
787 
788  return std::move(Msg);
789  }
790 
791  StringRef getTagDescription() const override {
792  // TODO: Remember a few examples of generated messages
793  // and display them in the ExplodedGraph dump by
794  // returning them from this function.
795  return "Note Tag";
796  }
797 
798  bool isPrunable() const { return IsPrunable; }
799 
800  friend class Factory;
801  friend class TagVisitor;
802 };
803 
804 } // namespace ento
805 
806 } // namespace clang
807 
808 #endif // LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_BUGREPORTER_H
clang::ento::BugReport::Profile
virtual void Profile(llvm::FoldingSetNodeID &hash) const =0
Reports are uniqued to ensure that we do not emit multiple diagnostics for each bug.
clang::ento::PathSensitiveBugReport::isValid
bool isValid() const
Returns whether or not this report should be considered valid.
Definition: BugReporter.h:468
clang::ento::PathSensitiveBugReport::StackHints
std::map< PathDiagnosticPieceRef, std::unique_ptr< StackHintGenerator > > StackHints
If an event occurs in a different frame than the final diagnostic, supply a message that will be used...
Definition: BugReporter.h:366
clang::ento::BugReporterData::~BugReporterData
virtual ~BugReporterData()=default
clang::ento::PathSensitiveBugReport::InterestingLocationContexts
llvm::SmallSet< const LocationContext *, 2 > InterestingLocationContexts
A set of location contexts that correspoind to call sites which should be considered "interesting".
Definition: BugReporter.h:323
clang::ento::PathSensitiveBugReport::addVisitor
void addVisitor(std::unique_ptr< BugReporterVisitor > visitor)
Add custom or predefined bug report visitors to this report.
Definition: BugReporter.cpp:2157
clang::ento::PathSensitiveBugReport::UniqueingLocation
PathDiagnosticLocation UniqueingLocation
Reports with different uniqueing locations are considered to be different for the purposes of dedupli...
Definition: BugReporter.h:355
clang::ento::PathDiagnosticLocation
Definition: PathDiagnostic.h:195
clang::ento::PathSensitiveBugReport::addCallStackHint
void addCallStackHint(PathDiagnosticPieceRef Piece, std::unique_ptr< StackHintGenerator > StackHint)
Definition: BugReporter.h:519
clang::LocationContext
It wraps the AnalysisDeclContext to represent both the call stack with the help of StackFrameContext ...
Definition: AnalysisDeclContext.h:215
clang::ento::BugReport::getFixits
llvm::ArrayRef< FixItHint > getFixits() const
Definition: BugReporter.h:244
SVals.h
clang::ento::BugReporterData
Definition: BugReporter.h:569
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:210
clang::ento::BugReport::Kind::Basic
@ Basic
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::ento::NoteTag::isPrunable
bool isPrunable() const
Definition: BugReporter.h:798
clang::ento::BugReporter::EQClasses_iterator
llvm::FoldingSet< BugReportEquivClass >::iterator EQClasses_iterator
Iterator over the set of BugReports tracked by the BugReporter.
Definition: BugReporter.h:610
clang::ento::BasicBugReport::Profile
void Profile(llvm::FoldingSetNodeID &hash) const override
Reports are uniqued to ensure that we do not emit multiple diagnostics for each bug.
Definition: BugReporter.cpp:2186
clang::ento::PathDiagnosticPieceRef
std::shared_ptr< PathDiagnosticPiece > PathDiagnosticPieceRef
Definition: PathDiagnostic.h:492
clang::ento::StackHintGeneratorForSymbol::getMessageForSymbolNotFound
virtual std::string getMessageForSymbolNotFound()
Definition: BugReporter.h:112
clang::ProgramPointTag
ProgramPoints can be "tagged" as representing points specific to a given analysis entity.
Definition: ProgramPoint.h:38
llvm::SmallVector
Definition: LLVM.h:38
clang::ento::BugReportEquivClass::Profile
void Profile(llvm::FoldingSetNodeID &ID) const
Definition: BugReporter.h:559
clang::ento::PathSensitiveBugReport::ErrorNode
const ExplodedNode * ErrorNode
The ExplodedGraph node against which the report was thrown.
Definition: BugReporter.h:298
clang::ento::StackHintGeneratorForSymbol
Constructs a Stack hint for the given symbol.
Definition: BugReporter.h:91
clang::ento::StackHintGeneratorForSymbol::getMessageForReturn
virtual std::string getMessageForReturn(const CallExpr *CallExpr)
Definition: BugReporter.h:108
clang::ento::ExplodedNode
Definition: ExplodedGraph.h:65
clang::ento::BugReporterData::getPreprocessor
virtual Preprocessor & getPreprocessor()=0
clang::ento::BugReportEquivClass::BugReportEquivClass
BugReportEquivClass(std::unique_ptr< BugReport > R)
Definition: BugReporter.h:555
clang::SourceRange::isValid
bool isValid() const
Definition: SourceLocation.h:225
clang::ento::StackHintGeneratorForSymbol::getMessage
std::string getMessage(const ExplodedNode *N) override
Search the call expression for the symbol Sym and dispatch the 'getMessageForX()' methods to construc...
Definition: BugReporter.cpp:286
llvm::Optional
Definition: LLVM.h:40
clang::ento::StackHintGeneratorForSymbol::StackHintGeneratorForSymbol
StackHintGeneratorForSymbol(SymbolRef S, StringRef M)
Definition: BugReporter.h:97
clang::ento::BugReport::Notes
SmallVector< std::shared_ptr< PathDiagnosticNotePiece >, 4 > Notes
Definition: BugReporter.h:133
clang::ento::bugreporter::TrackingKind
TrackingKind
Specifies the type of tracking for an expression.
Definition: BugReporterVisitors.h:95
clang::ento::PathSensitiveBugReport::shouldPrunePath
bool shouldPrunePath() const
Indicates whether or not any path pruning should take place when generating a PathDiagnostic from thi...
Definition: BugReporter.h:406
clang::ento::PathSensitiveBugReport::visitors
visitor_range visitors()
Definition: BugReporter.h:510
clang::ento::PathSensitiveBugReport::getStmt
const Stmt * getStmt() const
Definition: BugReporter.cpp:2383
clang::ento::PathSensitiveBugReport::getCallStackMessage
std::string getCallStackMessage(PathDiagnosticPieceRef Piece, const ExplodedNode *N) const
Produce the hint for the given node.
Definition: BugReporter.h:531
clang::ento::BasicBugReport::getDeclWithIssue
const Decl * getDeclWithIssue() const override
The smallest declaration that contains the bug location.
Definition: BugReporter.h:268
clang::ento::PathSensitiveBugReport::InterestingSymbols
llvm::DenseMap< SymbolRef, bugreporter::TrackingKind > InterestingSymbols
Profile to identify equivalent bug reports for error report coalescing.
Definition: BugReporter.h:311
clang::ento::BasicBugReport::getUniqueingLocation
PathDiagnosticLocation getUniqueingLocation() const override
Get the location on which the report should be uniqued.
Definition: BugReporter.h:272
clang::interp::EQ
bool EQ(InterpState &S, CodePtr OpPC)
Definition: Interp.h:483
clang::ento::PathSensitiveBugReport::InvalidationRecord
std::pair< const void *, const void * > InvalidationRecord
Used to track unique reasons why a bug report might be invalid.
Definition: BugReporter.h:341
clang::ento::BugReporterData::getAnalyzerOptions
virtual AnalyzerOptions & getAnalyzerOptions()=0
clang::ento::BugReport::BT
const BugType & BT
Definition: BugReporter.h:128
clang::ento::BugReporter::FlushReports
void FlushReports()
Generate and flush diagnostics for all bug reports.
Definition: BugReporter.cpp:2477
clang::ento::PathSensitiveBugReport::getUniqueingLocation
PathDiagnosticLocation getUniqueingLocation() const override
Get the location on which the report should be uniqued.
Definition: BugReporter.h:412
clang::SourceManager
This class handles loading and caching of source files into memory.
Definition: SourceManager.h:636
clang::ento::PathSensitiveBugReport::markInvalid
void markInvalid(const void *Tag, const void *Data)
Marks the current report as invalid, meaning that it is probably a false positive and should not be r...
Definition: BugReporter.h:481
Preprocessor.h
clang::ento::MemRegion
MemRegion - The root abstract class for all memory regions.
Definition: MemRegion.h:95
clang::FixItHint
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:71
clang::CodeGen::AlignmentSource::Decl
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
clang::ento::BugReporterContext::BugReporterContext
BugReporterContext(PathSensitiveBugReporter &br)
Definition: BugReporter.h:707
clang::ento::BugReporterData::getSourceManager
virtual SourceManager & getSourceManager()=0
clang::ento::NoteTag::generateMessage
Optional< std::string > generateMessage(BugReporterContext &BRC, PathSensitiveBugReport &R) const
Definition: BugReporter.h:782
clang::ento::BasicBugReport::BasicBugReport
BasicBugReport(const BugType &bt, StringRef desc, PathDiagnosticLocation l)
Definition: BugReporter.h:256
SymExpr.h
clang::ento::DataTag
The tag that carries some information with it.
Definition: BugReporter.h:738
V
#define V(N, I)
Definition: ASTContext.h:3237
clang::ento::BugReport::Ranges
SmallVector< SourceRange, 4 > Ranges
Definition: BugReporter.h:132
clang::ento::TagVisitor
The visitor detects NoteTags and displays the event notes they contain.
Definition: BugReporterVisitors.h:617
clang::ento::DiagnosticForConsumerMapTy
llvm::DenseMap< PathDiagnosticConsumer *, std::unique_ptr< PathDiagnostic > > DiagnosticForConsumerMapTy
A mapping from diagnostic consumers to the diagnostics they should consume.
Definition: BugReporter.h:71
clang::ento::BugReporter::EQClasses_begin
EQClasses_iterator EQClasses_begin()
Definition: BugReporter.h:611
clang::ento::PathSensitiveBugReport::TrackedConditions
llvm::SmallSet< const ExplodedNode *, 4 > TrackedConditions
Conditions we're already tracking.
Definition: BugReporter.h:351
clang::ento::PathSensitiveBugReport::getUniqueingDecl
const Decl * getUniqueingDecl() const override
Get the declaration containing the uniqueing location.
Definition: BugReporter.h:417
clang::ento::BugReporter::~BugReporter
virtual ~BugReporter()
Definition: BugReporter.cpp:2467
clang::ento::StackHintGenerator::~StackHintGenerator
virtual ~StackHintGenerator()=0
clang::ento::BugReporter::emitReport
virtual void emitReport(std::unique_ptr< BugReport > R)
Add the given report to the set of reports tracked by BugReporter.
Definition: BugReporter.cpp:2897
clang::ento::BugReporter::getPreprocessor
Preprocessor & getPreprocessor()
Definition: BugReporter.h:620
CheckerManager.h
clang::ento::DataTag::Factory::make
const DataTagType * make(Args &&... ConstructorArgs)
Definition: BugReporter.h:748
clang::ento::BugReporterContext::getSourceManager
const SourceManager & getSourceManager() const
Definition: BugReporter.h:721
clang::ento::BugReporter::getPathDiagnosticConsumers
ArrayRef< PathDiagnosticConsumer * > getPathDiagnosticConsumers()
Definition: BugReporter.h:605
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:209
clang::ento::SymExpr
Symbolic value.
Definition: SymExpr.h:29
clang::ento::PathDiagnosticLocation::isValid
bool isValid() const
Definition: PathDiagnostic.h:335
clang::ento::BasicBugReport::classof
static bool classof(const BugReport *R)
Definition: BugReporter.h:259
clang::ento::PathSensitiveBugReport::getErrorNode
const ExplodedNode * getErrorNode() const
Definition: BugReporter.h:402
clang::ento::BugType
Definition: BugType.h:27
clang::ento::BasicBugReport::getLocation
PathDiagnosticLocation getLocation() const override
The primary location of the bug report that points at the undesirable behavior in the code.
Definition: BugReporter.h:263
clang::ento::BugReporterContext::getAnalyzerOptions
const AnalyzerOptions & getAnalyzerOptions() const
Definition: BugReporter.h:725
clang::ento::DataTag::getTagDescription
StringRef getTagDescription() const override
Definition: BugReporter.h:740
clang::ento::BugReporter::getAnalyzerOptions
const AnalyzerOptions & getAnalyzerOptions()
Definition: BugReporter.h:618
clang::ento::CheckerNameRef
This wrapper is used to ensure that only StringRefs originating from the CheckerRegistry are used as ...
Definition: CheckerManager.h:106
clang::ento::PathSensitiveBugReport::visitor_end
visitor_iterator visitor_end()
Definition: BugReporter.h:509
clang::ento::PathSensitiveBugReport::PathSensitiveBugReport
PathSensitiveBugReport(const BugType &bt, StringRef desc, const ExplodedNode *errorNode)
Definition: BugReporter.h:369
clang::ento::PathSensitiveBugReport::hasCallStackHint
bool hasCallStackHint(PathDiagnosticPieceRef Piece) const
Definition: BugReporter.h:524
clang::ento::BugReporter::generateDiagnosticForConsumerMap
virtual std::unique_ptr< DiagnosticForConsumerMapTy > generateDiagnosticForConsumerMap(BugReport *exampleReport, ArrayRef< PathDiagnosticConsumer * > consumers, ArrayRef< BugReport * > bugReports)
Generate the diagnostics for the given bug report.
Definition: BugReporter.cpp:3200
clang::ento::BugReportEquivClass
Definition: BugReporter.h:544
clang::ento::BugReporterData::getASTContext
virtual ASTContext & getASTContext()=0
clang::ento::bugreporter::TrackingKind::Thorough
@ Thorough
Default tracking kind – specifies that as much information should be gathered about the tracked expre...
clang::ento::BugReporterContext
Definition: BugReporter.h:701
clang::ento::BugReporterData::getPathDiagnosticConsumers
virtual ArrayRef< PathDiagnosticConsumer * > getPathDiagnosticConsumers()=0
PathDiagnostic.h
clang::ento::PathSensitiveBugReporter::PathSensitiveBugReporter
PathSensitiveBugReporter(BugReporterData &d, ExprEngine &eng)
Definition: BugReporter.h:677
clang::ento::BugReporter
BugReporter is a utility class for generating PathDiagnostics for analysis.
Definition: BugReporter.h:585
clang::ento::NoteTag::classof
static bool classof(const ProgramPointTag *T)
Definition: BugReporter.h:778
clang::ento::BugReport::getKind
Kind getKind() const
Definition: BugReporter.h:147
clang::ento::ExplodedGraph
Definition: ExplodedGraph.h:302
ExplodedGraph.h
clang::ento::PathSensitiveBugReport::CallbacksSet
llvm::FoldingSet< BugReporterVisitor > CallbacksSet
Used for ensuring the visitors are only added once.
Definition: BugReporter.h:330
clang::ento::Loc
Definition: SVals.h:282
clang::ento::PathSensitiveBugReport::visitor_begin
visitor_iterator visitor_begin()
Iterators through the custom diagnostic visitors.
Definition: BugReporter.h:508
clang::ento::BugReporter::EQClasses_end
EQClasses_iterator EQClasses_end()
Definition: BugReporter.h:612
clang::ento::StackHintGenerator::getMessage
virtual std::string getMessage(const ExplodedNode *N)=0
Construct the Diagnostic message for the given ExplodedNode.
clang::ento::BugReport::getRanges
virtual ArrayRef< SourceRange > getRanges() const
Get the SourceRanges associated with the report.
Definition: BugReporter.h:229
clang::ento::BugReportEquivClass::getReports
ArrayRef< std::unique_ptr< BugReport > > getReports() const
Definition: BugReporter.h:557
clang::ento::DataTag::DataTag
DataTag(void *TagKind)
Definition: BugReporter.h:758
clang::ento::PathSensitiveBugReport::addTrackedCondition
bool addTrackedCondition(const ExplodedNode *Cond)
Notes that the condition of the CFGBlock associated with Cond is being tracked.
Definition: BugReporter.h:515
clang::ento::PathSensitiveBugReport::getDeclWithIssue
const Decl * getDeclWithIssue() const override
The smallest declaration that contains the bug location.
Definition: BugReporter.cpp:2177
SourceLocation.h
P
StringRef P
Definition: ASTMatchersInternal.cpp:563
clang::ento::PathSensitiveBugReporter::emitReport
void emitReport(std::unique_ptr< BugReport > R) override
Add the given report to the set of reports tracked by BugReporter.
Definition: BugReporter.cpp:2921
clang::ento::PathSensitiveBugReporter::getGraph
const ExplodedGraph & getGraph() const
getGraph - Get the exploded graph created by the analysis engine for the analyzed method or function.
Definition: BugReporter.cpp:2458
clang::ento::BugReport::Kind::PathSensitive
@ PathSensitive
clang::ento::BugReport::K
Kind K
Definition: BugReporter.h:127
clang::ento::BugReport::Description
std::string Description
Definition: BugReporter.h:130
clang::ento::PathSensitiveBugReport::getRanges
ArrayRef< SourceRange > getRanges() const override
Get the SourceRanges associated with the report.
Definition: BugReporter.cpp:2402
clang::ento::ProgramStateManager
Definition: ProgramState.h:502
clang::ento::BugReporter::getSourceManager
const SourceManager & getSourceManager()
Definition: BugReporter.h:616
clang::ento::BugReport::getDeclWithIssue
virtual const Decl * getDeclWithIssue() const =0
The smallest declaration that contains the bug location.
BugType.h
clang::ento::BugReporter::EmitBasicReport
void EmitBasicReport(const Decl *DeclWithIssue, const CheckerBase *Checker, StringRef BugName, StringRef BugCategory, StringRef BugStr, PathDiagnosticLocation Loc, ArrayRef< SourceRange > Ranges=None, ArrayRef< FixItHint > Fixits=None)
clang::ento::PathSensitiveBugReport::InterestingRegions
llvm::DenseMap< const MemRegion *, bugreporter::TrackingKind > InterestingRegions
A (stack of) set of regions that are registered with this report as being "interesting",...
Definition: BugReporter.h:319
clang::ento::StackHintGenerator
Interface for classes constructing Stack hints.
Definition: BugReporter.h:77
clang::ento::BugReport::~BugReport
virtual ~BugReport()=default
llvm::ArrayRef
Definition: LLVM.h:34
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:83
clang::ento::PathSensitiveBugReport::Callbacks
VisitorList Callbacks
A set of custom visitors which generate "event" diagnostics at interesting points in the path.
Definition: BugReporter.h:327
BugReporterVisitors.h
clang::ento::PathSensitiveBugReporter::getStateManager
ProgramStateManager & getStateManager() const
getStateManager - Return the state manager used by the analysis engine.
Definition: BugReporter.cpp:2462
clang::ento::CheckerBase
Definition: Checker.h:492
clang::ento::BugReport::addRange
void addRange(SourceRange R)
Add a range to a bug report.
Definition: BugReporter.h:222
LLVM.h
clang::ento::BugReport::getUniqueingLocation
virtual PathDiagnosticLocation getUniqueingLocation() const =0
Get the location on which the report should be uniqued.
clang::AnalyzerOptions
Stores options for the analyzer from the command line.
Definition: AnalyzerOptions.h:150
clang::ento::NoteTag::getTagDescription
StringRef getTagDescription() const override
Definition: BugReporter.h:791
clang::ento::BugReporter::BugReporter
BugReporter(BugReporterData &d)
Definition: BugReporter.cpp:2466
clang::ento::BugReport::addNote
void addNote(StringRef Msg, const PathDiagnosticLocation &Pos, ArrayRef< SourceRange > Ranges={})
Add new item to the list of additional notes that need to be attached to this report.
Definition: BugReporter.h:201
clang::ento::PathSensitiveBugReport::PathSensitiveBugReport
PathSensitiveBugReport(const BugType &bt, StringRef shortDesc, StringRef desc, const ExplodedNode *errorNode)
Definition: BugReporter.h:373
clang::ento::PathSensitiveBugReport::PathSensitiveBugReport
PathSensitiveBugReport(const BugType &bt, StringRef desc, const ExplodedNode *errorNode, PathDiagnosticLocation LocationToUnique, const Decl *DeclToUnique)
Create a PathSensitiveBugReport with a custom uniqueing location.
Definition: BugReporter.h:386
clang::ento::PathSensitiveBugReporter
GRBugReporter is used for generating path-sensitive reports.
Definition: BugReporter.h:664
clang::ento::BugReport::getUniqueingDecl
virtual const Decl * getUniqueingDecl() const =0
Get the declaration that corresponds to (usually contains) the uniqueing location.
clang::ento::ExprEngine
Definition: ExprEngine.h:123
ProgramState.h
clang::ento::BugReport::getDescription
StringRef getDescription() const
A verbose warning message that is appropriate for displaying next to the source code that introduces ...
Definition: BugReporter.h:157
clang::ento::BugReporterContext::getBugReporter
PathSensitiveBugReporter & getBugReporter()
Definition: BugReporter.h:711
clang::ento::BugReport::Kind
Kind
Definition: BugReporter.h:121
std
Definition: Format.h:4477
clang::ento::PathSensitiveBugReport
Definition: BugReporter.h:289
clang::ProgramPointTag::getTagKind
const void * getTagKind() const
Used to implement 'isKind' in subclasses.
Definition: ProgramPoint.h:45
clang::ento::PathSensitiveBugReport::markNotInteresting
void markNotInteresting(SymbolRef sym)
Definition: BugReporter.cpp:2266
clang::ento::BugReport
This class provides an interface through which checkers can create individual bug reports.
Definition: BugReporter.h:119
clang::Builtin::ID
ID
Definition: Builtins.h:52
clang::ento::BugReport::BugReport
BugReport(Kind kind, const BugType &bt, StringRef desc)
Definition: BugReporter.h:136
clang
Definition: CalledOnceCheck.h:17
clang::ento::PathSensitiveBugReport::visitor_range
llvm::iterator_range< visitor_iterator > visitor_range
Definition: BugReporter.h:293
clang::ento::PathSensitiveBugReport::getInterestingnessKind
Optional< bugreporter::TrackingKind > getInterestingnessKind(SymbolRef sym) const
Definition: BugReporter.cpp:2339
clang::ento::PathSensitiveBugReport::UniqueingDecl
const Decl * UniqueingDecl
Definition: BugReporter.h:356
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:71
clang::ento::PathSensitiveBugReport::ErrorNodeRange
const SourceRange ErrorNodeRange
The range that corresponds to ErrorNode's program point.
Definition: BugReporter.h:302
clang::ento::PathSensitiveBugReport::visitor_iterator
VisitorList::iterator visitor_iterator
Definition: BugReporter.h:292
clang::ento::BugReport::getNotes
ArrayRef< std::shared_ptr< PathDiagnosticNotePiece > > getNotes()
Definition: BugReporter.h:211
clang::ento::PathSensitiveBugReport::markInteresting
void markInteresting(SymbolRef sym, bugreporter::TrackingKind TKind=bugreporter::TrackingKind::Thorough)
Marks a symbol as interesting.
clang::ento::BugReport::getLocation
virtual PathDiagnosticLocation getLocation() const =0
The primary location of the bug report that points at the undesirable behavior in the code.
clang::ento::PathSensitiveBugReport::Profile
void Profile(llvm::FoldingSetNodeID &hash) const override
Profile to identify equivalent bug reports for error report coalescing.
Definition: BugReporter.cpp:2201
clang::ento::BugReport::getShortDescription
StringRef getShortDescription(bool UseFallback=true) const
A short general warning message that is appropriate for displaying in the list of all reported bugs.
Definition: BugReporter.h:163
clang::ento::PathSensitiveBugReporter::generatePathDiagnostics
std::unique_ptr< DiagnosticForConsumerMapTy > generatePathDiagnostics(ArrayRef< PathDiagnosticConsumer * > consumers, ArrayRef< PathSensitiveBugReport * > &bugReports)
bugReports A set of bug reports within a single equivalence class
Definition: BugReporter.cpp:2876
clang::ento::PathSensitiveBugReport::clearVisitors
void clearVisitors()
Remove all visitors attached to this bug report.
Definition: BugReporter.cpp:2173
clang::ento::PathSensitiveBugReport::classof
static bool classof(const BugReport *R)
Definition: BugReporter.h:398
clang::ento::PathSensitiveBugReport::isInteresting
bool isInteresting(SymbolRef sym) const
Definition: BugReporter.cpp:2369
clang::ento::Checker
Definition: Checker.h:517
clang::ento::BasicBugReport
Definition: BugReporter.h:251
clang::ento::BugReport::BugReport
BugReport(Kind K, const BugType &BT, StringRef ShortDescription, StringRef Description)
Definition: BugReporter.h:139
clang::ento::SVal
SVal - This represents a symbolic expression, which can be either an L-value or an R-value.
Definition: SVals.h:73
clang::ento::BugReport::addFixItHint
void addFixItHint(const FixItHint &F)
Add a fix-it hint to the bug report.
Definition: BugReporter.h:240
clang::ento::PathSensitiveBugReport::Invalidations
llvm::SmallSet< InvalidationRecord, 4 > Invalidations
If non-empty, this bug report is likely a false positive and should not be shown to the user.
Definition: BugReporter.h:348
clang::ento::BugReport::ShortDescription
std::string ShortDescription
Definition: BugReporter.h:129
clang::ento::PathSensitiveBugReport::DoNotPrunePath
bool DoNotPrunePath
When set, this flag disables all callstack pruning from a diagnostic path.
Definition: BugReporter.h:335
llvm::SmallVectorImpl
Definition: Randstruct.h:18
clang::ento::BasicBugReport::setDeclWithIssue
void setDeclWithIssue(const Decl *declWithIssue)
Specifically set the Decl where an issue occurred.
Definition: BugReporter.h:282
clang::ento::StackHintGeneratorForSymbol::~StackHintGeneratorForSymbol
~StackHintGeneratorForSymbol() override=default
clang::Expr
This represents one expression.
Definition: Expr.h:109
clang::Preprocessor
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:129
clang::transformer::name
RangeSelector name(std::string ID)
Given a node with a "name", (like NamedDecl, DeclRefExpr, CxxCtorInitializer, and TypeLoc) selects th...
Definition: RangeSelector.cpp:200
clang::ento::BugReporterContext::getASTContext
ASTContext & getASTContext() const
Definition: BugReporter.h:717
clang::ento::BugReporterContext::~BugReporterContext
virtual ~BugReporterContext()=default
clang::ento::PathSensitiveBugReport::disablePathPruning
void disablePathPruning()
Disable all path pruning when generating a PathDiagnostic.
Definition: BugReporter.h:409
clang::ento::NoteTag
The tag upon which the TagVisitor reacts.
Definition: BugReporter.h:763
clang::ento::BugReport::Fixits
SmallVector< FixItHint, 4 > Fixits
Definition: BugReporter.h:134
clang::ento::PathSensitiveBugReport::getLocation
PathDiagnosticLocation getLocation() const override
The primary location of the bug report that points at the undesirable behavior in the code.
Definition: BugReporter.cpp:2412
clang::ento::StackHintGeneratorForSymbol::getMessageForArg
virtual std::string getMessageForArg(const Expr *ArgE, unsigned ArgIndex)
Produces the message of the following form: 'Msg via Nth parameter'.
Definition: BugReporter.cpp:334
clang::ento::NoteTag::Callback
std::function< std::string(BugReporterContext &, PathSensitiveBugReport &)> Callback
Definition: BugReporter.h:766
clang::ento::BugReporterContext::getStateManager
ProgramStateManager & getStateManager() const
Definition: BugReporter.h:713
clang::ento::BugReport::getBugType
const BugType & getBugType() const
Definition: BugReporter.h:149
clang::CallExpr
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2810
clang::ento::BasicBugReport::getUniqueingDecl
const Decl * getUniqueingDecl() const override
Get the declaration that corresponds to (usually contains) the uniqueing location.
Definition: BugReporter.h:276
clang::diag::kind
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:62
clang::ento::DataTag::Factory
Definition: BugReporter.h:743
clang::ento::PathSensitiveBugReport::addVisitor
void addVisitor(Args &&... ConstructorArgs)
Definition: BugReporter.h:498
clang::ento::BugReporter::getContext
ASTContext & getContext()
Definition: BugReporter.h:614