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