1 //===--- PathDiagnostic.h - Path-Specific Diagnostic Handling ---*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the PathDiagnostic-related interfaces.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_CLANG_PATH_DIAGNOSTIC_H
15 #define LLVM_CLANG_PATH_DIAGNOSTIC_H
17 #include "clang/Basic/Diagnostic.h"
18 #include "llvm/ADT/FoldingSet.h"
32 //===----------------------------------------------------------------------===//
33 // High-level interface for handlers of path-sensitive diagnostics.
34 //===----------------------------------------------------------------------===//
38 class PathDiagnosticClient : public DiagnosticClient {
40 PathDiagnosticClient() {}
42 virtual ~PathDiagnosticClient() {}
45 FlushDiagnostics(llvm::SmallVectorImpl<std::string> *FilesMade = 0) = 0;
47 void FlushDiagnostics(llvm::SmallVectorImpl<std::string> &FilesMade) {
48 FlushDiagnostics(&FilesMade);
51 virtual llvm::StringRef getName() const = 0;
53 virtual void HandleDiagnostic(Diagnostic::Level DiagLevel,
54 const DiagnosticInfo &Info);
55 virtual void HandlePathDiagnostic(const PathDiagnostic* D) = 0;
57 enum PathGenerationScheme { Minimal, Extensive };
58 virtual PathGenerationScheme getGenerationScheme() const { return Minimal; }
59 virtual bool supportsLogicalOpControlFlow() const { return false; }
60 virtual bool supportsAllBlockEdges() const { return false; }
61 virtual bool useVerboseDescription() const { return true; }
64 //===----------------------------------------------------------------------===//
65 // Path-sensitive diagnostics.
66 //===----------------------------------------------------------------------===//
68 class PathDiagnosticRange : public SourceRange {
72 PathDiagnosticRange(const SourceRange &R, bool isP = false)
73 : SourceRange(R), isPoint(isP) {}
76 class PathDiagnosticLocation {
78 enum Kind { RangeK, SingleLocK, StmtK, DeclK } K;
82 const SourceManager *SM;
84 PathDiagnosticLocation()
85 : K(SingleLocK), S(0), D(0), SM(0) {}
87 PathDiagnosticLocation(FullSourceLoc L)
88 : K(SingleLocK), R(L, L), S(0), D(0), SM(&L.getManager()) {}
90 PathDiagnosticLocation(const Stmt *s, const SourceManager &sm)
91 : K(StmtK), S(s), D(0), SM(&sm) {}
93 PathDiagnosticLocation(SourceRange r, const SourceManager &sm)
94 : K(RangeK), R(r), S(0), D(0), SM(&sm) {}
96 PathDiagnosticLocation(const Decl *d, const SourceManager &sm)
97 : K(DeclK), S(0), D(d), SM(&sm) {}
99 bool operator==(const PathDiagnosticLocation &X) const {
100 return K == X.K && R == X.R && S == X.S && D == X.D;
103 bool operator!=(const PathDiagnosticLocation &X) const {
104 return K != X.K || R != X.R || S != X.S || D != X.D;;
107 PathDiagnosticLocation& operator=(const PathDiagnosticLocation &X) {
116 bool isValid() const {
120 const SourceManager& getSourceManager() const { assert(isValid());return *SM;}
122 FullSourceLoc asLocation() const;
123 PathDiagnosticRange asRange() const;
124 const Stmt *asStmt() const { assert(isValid()); return S; }
125 const Decl *asDecl() const { assert(isValid()); return D; }
127 bool hasRange() const { return K == StmtK || K == RangeK || K == DeclK; }
130 *this = PathDiagnosticLocation();
135 const SourceManager& getManager() const { assert(isValid()); return *SM; }
137 void Profile(llvm::FoldingSetNodeID &ID) const;
140 class PathDiagnosticLocationPair {
142 PathDiagnosticLocation Start, End;
144 PathDiagnosticLocationPair(const PathDiagnosticLocation &start,
145 const PathDiagnosticLocation &end)
146 : Start(start), End(end) {}
148 const PathDiagnosticLocation &getStart() const { return Start; }
149 const PathDiagnosticLocation &getEnd() const { return End; }
156 void Profile(llvm::FoldingSetNodeID &ID) const {
162 //===----------------------------------------------------------------------===//
163 // Path "pieces" for path-sensitive diagnostics.
164 //===----------------------------------------------------------------------===//
166 class PathDiagnosticPiece {
168 enum Kind { ControlFlow, Event, Macro };
169 enum DisplayHint { Above, Below };
172 const std::string str;
173 std::vector<FixItHint> FixItHints;
175 const DisplayHint Hint;
176 std::vector<SourceRange> ranges;
179 PathDiagnosticPiece();
180 PathDiagnosticPiece(const PathDiagnosticPiece &P);
181 PathDiagnosticPiece& operator=(const PathDiagnosticPiece &P);
184 PathDiagnosticPiece(llvm::StringRef s, Kind k, DisplayHint hint = Below);
186 PathDiagnosticPiece(Kind k, DisplayHint hint = Below);
189 virtual ~PathDiagnosticPiece();
191 const std::string& getString() const { return str; }
193 /// getDisplayHint - Return a hint indicating where the diagnostic should
194 /// be displayed by the PathDiagnosticClient.
195 DisplayHint getDisplayHint() const { return Hint; }
197 virtual PathDiagnosticLocation getLocation() const = 0;
198 virtual void flattenLocations() = 0;
200 Kind getKind() const { return kind; }
202 void addRange(SourceRange R) { ranges.push_back(R); }
204 void addRange(SourceLocation B, SourceLocation E) {
205 ranges.push_back(SourceRange(B,E));
208 void addFixItHint(const FixItHint& Hint) {
209 FixItHints.push_back(Hint);
212 typedef const SourceRange* range_iterator;
214 range_iterator ranges_begin() const {
215 return ranges.empty() ? NULL : &ranges[0];
218 range_iterator ranges_end() const {
219 return ranges_begin() + ranges.size();
222 typedef const FixItHint *fixit_iterator;
224 fixit_iterator fixit_begin() const {
225 return FixItHints.empty()? 0 : &FixItHints[0];
228 fixit_iterator fixit_end() const {
229 return FixItHints.empty()? 0
230 : &FixItHints[0] + FixItHints.size();
233 static inline bool classof(const PathDiagnosticPiece* P) {
237 virtual void Profile(llvm::FoldingSetNodeID &ID) const;
240 class PathDiagnosticSpotPiece : public PathDiagnosticPiece {
242 PathDiagnosticLocation Pos;
244 PathDiagnosticSpotPiece(const PathDiagnosticLocation &pos,
246 PathDiagnosticPiece::Kind k,
247 bool addPosRange = true)
248 : PathDiagnosticPiece(s, k), Pos(pos) {
249 assert(Pos.asLocation().isValid() &&
250 "PathDiagnosticSpotPiece's must have a valid location.");
251 if (addPosRange && Pos.hasRange()) addRange(Pos.asRange());
254 PathDiagnosticLocation getLocation() const { return Pos; }
255 virtual void flattenLocations() { Pos.flatten(); }
257 virtual void Profile(llvm::FoldingSetNodeID &ID) const;
260 class PathDiagnosticEventPiece : public PathDiagnosticSpotPiece {
263 PathDiagnosticEventPiece(const PathDiagnosticLocation &pos,
264 llvm::StringRef s, bool addPosRange = true)
265 : PathDiagnosticSpotPiece(pos, s, Event, addPosRange) {}
267 ~PathDiagnosticEventPiece();
269 static inline bool classof(const PathDiagnosticPiece* P) {
270 return P->getKind() == Event;
274 class PathDiagnosticControlFlowPiece : public PathDiagnosticPiece {
275 std::vector<PathDiagnosticLocationPair> LPairs;
277 PathDiagnosticControlFlowPiece(const PathDiagnosticLocation &startPos,
278 const PathDiagnosticLocation &endPos,
280 : PathDiagnosticPiece(s, ControlFlow) {
281 LPairs.push_back(PathDiagnosticLocationPair(startPos, endPos));
284 PathDiagnosticControlFlowPiece(const PathDiagnosticLocation &startPos,
285 const PathDiagnosticLocation &endPos)
286 : PathDiagnosticPiece(ControlFlow) {
287 LPairs.push_back(PathDiagnosticLocationPair(startPos, endPos));
290 ~PathDiagnosticControlFlowPiece();
292 PathDiagnosticLocation getStartLocation() const {
293 assert(!LPairs.empty() &&
294 "PathDiagnosticControlFlowPiece needs at least one location.");
295 return LPairs[0].getStart();
298 PathDiagnosticLocation getEndLocation() const {
299 assert(!LPairs.empty() &&
300 "PathDiagnosticControlFlowPiece needs at least one location.");
301 return LPairs[0].getEnd();
304 void push_back(const PathDiagnosticLocationPair &X) { LPairs.push_back(X); }
306 virtual PathDiagnosticLocation getLocation() const {
307 return getStartLocation();
310 typedef std::vector<PathDiagnosticLocationPair>::iterator iterator;
311 iterator begin() { return LPairs.begin(); }
312 iterator end() { return LPairs.end(); }
314 virtual void flattenLocations() {
315 for (iterator I=begin(), E=end(); I!=E; ++I) I->flatten();
318 typedef std::vector<PathDiagnosticLocationPair>::const_iterator
320 const_iterator begin() const { return LPairs.begin(); }
321 const_iterator end() const { return LPairs.end(); }
323 static inline bool classof(const PathDiagnosticPiece* P) {
324 return P->getKind() == ControlFlow;
327 virtual void Profile(llvm::FoldingSetNodeID &ID) const;
330 class PathDiagnosticMacroPiece : public PathDiagnosticSpotPiece {
331 std::vector<PathDiagnosticPiece*> SubPieces;
333 PathDiagnosticMacroPiece(const PathDiagnosticLocation &pos)
334 : PathDiagnosticSpotPiece(pos, "", Macro) {}
336 ~PathDiagnosticMacroPiece();
338 bool containsEvent() const;
340 void push_back(PathDiagnosticPiece* P) { SubPieces.push_back(P); }
342 typedef std::vector<PathDiagnosticPiece*>::iterator iterator;
343 iterator begin() { return SubPieces.begin(); }
344 iterator end() { return SubPieces.end(); }
346 virtual void flattenLocations() {
347 PathDiagnosticSpotPiece::flattenLocations();
348 for (iterator I=begin(), E=end(); I!=E; ++I) (*I)->flattenLocations();
351 typedef std::vector<PathDiagnosticPiece*>::const_iterator const_iterator;
352 const_iterator begin() const { return SubPieces.begin(); }
353 const_iterator end() const { return SubPieces.end(); }
355 static inline bool classof(const PathDiagnosticPiece* P) {
356 return P->getKind() == Macro;
359 virtual void Profile(llvm::FoldingSetNodeID &ID) const;
362 /// PathDiagnostic - PathDiagnostic objects represent a single path-sensitive
363 /// diagnostic. It represents an ordered-collection of PathDiagnosticPieces,
364 /// each which represent the pieces of the path.
365 class PathDiagnostic : public llvm::FoldingSetNode {
366 std::deque<PathDiagnosticPiece*> path;
370 std::string Category;
371 std::deque<std::string> OtherDesc;
376 PathDiagnostic(llvm::StringRef bugtype, llvm::StringRef desc,
377 llvm::StringRef category);
381 llvm::StringRef getDescription() const { return Desc; }
382 llvm::StringRef getBugType() const { return BugType; }
383 llvm::StringRef getCategory() const { return Category; }
385 typedef std::deque<std::string>::const_iterator meta_iterator;
386 meta_iterator meta_begin() const { return OtherDesc.begin(); }
387 meta_iterator meta_end() const { return OtherDesc.end(); }
388 void addMeta(llvm::StringRef s) { OtherDesc.push_back(s); }
390 PathDiagnosticLocation getLocation() const {
391 assert(Size > 0 && "getLocation() requires a non-empty PathDiagnostic.");
392 return rbegin()->getLocation();
395 void push_front(PathDiagnosticPiece* piece) {
397 path.push_front(piece);
401 void push_back(PathDiagnosticPiece* piece) {
403 path.push_back(piece);
407 PathDiagnosticPiece* back() {
411 const PathDiagnosticPiece* back() const {
415 unsigned size() const { return Size; }
416 bool empty() const { return Size == 0; }
418 void resetPath(bool deletePieces = true);
422 typedef std::deque<PathDiagnosticPiece*>::iterator ImplTy;
424 typedef PathDiagnosticPiece value_type;
425 typedef value_type& reference;
426 typedef value_type* pointer;
427 typedef ptrdiff_t difference_type;
428 typedef std::bidirectional_iterator_tag iterator_category;
434 iterator(const ImplTy& i) : I(i) {}
436 bool operator==(const iterator& X) const { return I == X.I; }
437 bool operator!=(const iterator& X) const { return I != X.I; }
439 PathDiagnosticPiece& operator*() const { return **I; }
440 PathDiagnosticPiece* operator->() const { return *I; }
442 iterator& operator++() { ++I; return *this; }
443 iterator& operator--() { --I; return *this; }
446 class const_iterator {
448 typedef std::deque<PathDiagnosticPiece*>::const_iterator ImplTy;
450 typedef const PathDiagnosticPiece value_type;
451 typedef value_type& reference;
452 typedef value_type* pointer;
453 typedef ptrdiff_t difference_type;
454 typedef std::bidirectional_iterator_tag iterator_category;
460 const_iterator(const ImplTy& i) : I(i) {}
462 bool operator==(const const_iterator& X) const { return I == X.I; }
463 bool operator!=(const const_iterator& X) const { return I != X.I; }
465 reference operator*() const { return **I; }
466 pointer operator->() const { return *I; }
468 const_iterator& operator++() { ++I; return *this; }
469 const_iterator& operator--() { --I; return *this; }
472 typedef std::reverse_iterator<iterator> reverse_iterator;
473 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
475 // forward iterator creation methods.
477 iterator begin() { return path.begin(); }
478 iterator end() { return path.end(); }
480 const_iterator begin() const { return path.begin(); }
481 const_iterator end() const { return path.end(); }
483 // reverse iterator creation methods.
484 reverse_iterator rbegin() { return reverse_iterator(end()); }
485 const_reverse_iterator rbegin() const{ return const_reverse_iterator(end()); }
486 reverse_iterator rend() { return reverse_iterator(begin()); }
487 const_reverse_iterator rend() const { return const_reverse_iterator(begin());}
489 void flattenLocations() {
490 for (iterator I = begin(), E = end(); I != E; ++I) I->flattenLocations();
493 void Profile(llvm::FoldingSetNodeID &ID) const;
496 } // end GR namespace
498 } //end clang namespace