maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[analyzer][NFC] Refactoring BugReporter.cpp P3.: std::shared_pointer<PathDiagnosticPiece> -> PathDiagnosticPieceRef 

find clang/ -type f -exec sed -i 's/std::shared_ptr<PathDiagnosticPiece>/PathDiagnosticPieceRef/g' {} \;
git diff -U3 --no-color HEAD^ | clang-format-diff-6.0 -p1 -i

Just as C++ is meant to be refactored, right?

Differential Revision: https://reviews.llvm.org/D65381

llvm-svn: 368717
This commit is contained in:
Kristof Umann 2019-08-13 16:45:48 +00:00
parent e842314e76
commit 6d716ef181
24 changed files with 251 additions and 277 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

115
clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h
View File

@ -38,6 +38,7 @@ class BugReporterContext;
class ExplodedNode;
class MemRegion;
class PathDiagnosticPiece;
using PathDiagnosticPieceRef = std::shared_ptr<PathDiagnosticPiece>;
/// BugReporterVisitors are used to add custom diagnostics along a path.
class BugReporterVisitor : public llvm::FoldingSetNode {
@ -57,9 +58,9 @@ public:
///
/// The last parameter can be used to register a new visitor with the given
/// BugReport while processing a node.
virtual std::shared_ptr<PathDiagnosticPiece>
VisitNode(const ExplodedNode *Succ,
BugReporterContext &BRC, BugReport &BR) = 0;
virtual PathDiagnosticPieceRef VisitNode(const ExplodedNode *Succ,
BugReporterContext &BRC,
BugReport &BR) = 0;
/// Last function called on the visitor, no further calls to VisitNode
/// would follow.
@ -72,15 +73,15 @@ public:
///
/// NOTE that this function can be implemented on at most one used visitor,
/// and otherwise it crahes at runtime.
virtual std::shared_ptr<PathDiagnosticPiece>
virtual PathDiagnosticPieceRef
getEndPath(BugReporterContext &BRC, const ExplodedNode *N, BugReport &BR);
virtual void Profile(llvm::FoldingSetNodeID &ID) const = 0;
/// Generates the default final diagnostic piece.
static std::shared_ptr<PathDiagnosticPiece>
getDefaultEndPath(BugReporterContext &BRC, const ExplodedNode *N,
BugReport &BR);
static PathDiagnosticPieceRef getDefaultEndPath(BugReporterContext &BRC,
const ExplodedNode *N,
BugReport &BR);
};
/// Finds last store into the given region,
@ -106,9 +107,9 @@ public:
void Profile(llvm::FoldingSetNodeID &ID) const override;
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
};
class TrackConstraintBRVisitor final : public BugReporterVisitor {
@ -132,9 +133,9 @@ public:
/// to make all PathDiagnosticPieces created by this visitor.
static const char *getTag();
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
private:
/// Checks if the constraint is valid in the current state.
@ -150,9 +151,9 @@ public:
ID.AddPointer(&x);
}
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
/// If the statement is a message send expression with nil receiver, returns
/// the receiver expression. Returns NULL otherwise.
@ -175,39 +176,40 @@ public:
/// to make all PathDiagnosticPieces created by this visitor.
static const char *getTag();
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
std::shared_ptr<PathDiagnosticPiece> VisitNodeImpl(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR);
PathDiagnosticPieceRef VisitNodeImpl(const ExplodedNode *N,
BugReporterContext &BRC, BugReport &BR);
std::shared_ptr<PathDiagnosticPiece>
VisitTerminator(const Stmt *Term, const ExplodedNode *N,
const CFGBlock *srcBlk, const CFGBlock *dstBlk, BugReport &R,
BugReporterContext &BRC);
PathDiagnosticPieceRef VisitTerminator(const Stmt *Term,
const ExplodedNode *N,
const CFGBlock *SrcBlk,
const CFGBlock *DstBlk, BugReport &R,
BugReporterContext &BRC);
std::shared_ptr<PathDiagnosticPiece>
VisitTrueTest(const Expr *Cond, BugReporterContext &BRC, BugReport &R,
const ExplodedNode *N, bool TookTrue);
PathDiagnosticPieceRef VisitTrueTest(const Expr *Cond,
BugReporterContext &BRC, BugReport &R,
const ExplodedNode *N, bool TookTrue);
std::shared_ptr<PathDiagnosticPiece>
VisitTrueTest(const Expr *Cond, const DeclRefExpr *DR,
BugReporterContext &BRC, BugReport &R, const ExplodedNode *N,
bool TookTrue, bool IsAssuming);
PathDiagnosticPieceRef VisitTrueTest(const Expr *Cond, const DeclRefExpr *DR,
BugReporterContext &BRC, BugReport &R,
const ExplodedNode *N, bool TookTrue,
bool IsAssuming);
std::shared_ptr<PathDiagnosticPiece>
VisitTrueTest(const Expr *Cond, const BinaryOperator *BExpr,
BugReporterContext &BRC, BugReport &R, const ExplodedNode *N,
bool TookTrue, bool IsAssuming);
PathDiagnosticPieceRef VisitTrueTest(const Expr *Cond,
const BinaryOperator *BExpr,
BugReporterContext &BRC, BugReport &R,
const ExplodedNode *N, bool TookTrue,
bool IsAssuming);
std::shared_ptr<PathDiagnosticPiece>
VisitTrueTest(const Expr *Cond, const MemberExpr *ME, BugReporterContext &BRC,
BugReport &R, const ExplodedNode *N, bool TookTrue,
bool IsAssuming);
PathDiagnosticPieceRef VisitTrueTest(const Expr *Cond, const MemberExpr *ME,
BugReporterContext &BRC, BugReport &R,
const ExplodedNode *N, bool TookTrue,
bool IsAssuming);
std::shared_ptr<PathDiagnosticPiece>
PathDiagnosticPieceRef
VisitConditionVariable(StringRef LhsString, const Expr *CondVarExpr,
BugReporterContext &BRC, BugReport &R,
const ExplodedNode *N, bool TookTrue);
@ -251,9 +253,8 @@ public:
ID.AddPointer(getTag());
}
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *,
BugReporterContext &,
BugReport &) override {
PathDiagnosticPieceRef VisitNode(const ExplodedNode *, BugReporterContext &,
BugReport &) override {
return nullptr;
}
@ -279,9 +280,9 @@ public:
ID.AddPointer(R);
}
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
};
class SuppressInlineDefensiveChecksVisitor final : public BugReporterVisitor {
@ -308,9 +309,9 @@ public:
/// to make all PathDiagnosticPieces created by this visitor.
static const char *getTag();
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *Succ,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *Succ,
BugReporterContext &BRC,
BugReport &BR) override;
};
/// The bug visitor will walk all the nodes in a path and collect all the
@ -326,9 +327,9 @@ public:
void Profile(llvm::FoldingSetNodeID &ID) const override;
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
void finalizeVisitor(BugReporterContext &BRC, const ExplodedNode *EndPathNode,
BugReport &BR) override;
@ -340,9 +341,9 @@ class TagVisitor : public BugReporterVisitor {
public:
void Profile(llvm::FoldingSetNodeID &ID) const override;
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &R) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &R) override;
};
namespace bugreporter {

6
clang/include/clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h
View File

@ -446,7 +446,9 @@ public:
virtual void dump() const = 0;
};
class PathPieces : public std::list<std::shared_ptr<PathDiagnosticPiece>> {
using PathDiagnosticPieceRef = std::shared_ptr<PathDiagnosticPiece>;
class PathPieces : public std::list<PathDiagnosticPieceRef> {
void flattenTo(PathPieces &Primary, PathPieces &Current,
bool ShouldFlattenMacros) const;
@ -836,7 +838,7 @@ public:
bool isWithinCall() const { return !pathStack.empty(); }
void setEndOfPath(std::shared_ptr<PathDiagnosticPiece> EndPiece) {
void setEndOfPath(PathDiagnosticPieceRef EndPiece) {
assert(!Loc.isValid() && "End location already set!");
Loc = EndPiece->getLocation();
assert(Loc.isValid() && "Invalid location for end-of-path piece");

11
clang/lib/StaticAnalyzer/Checkers/DeleteWithNonVirtualDtorChecker.cpp
View File

@ -45,9 +45,9 @@ class DeleteWithNonVirtualDtorChecker
static int X = 0;
ID.AddPointer(&X);
}
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
private:
bool Satisfied;
@ -100,10 +100,9 @@ void DeleteWithNonVirtualDtorChecker::checkPreStmt(const CXXDeleteExpr *DE,
C.emitReport(std::move(R));
}
std::shared_ptr<PathDiagnosticPiece>
PathDiagnosticPieceRef
DeleteWithNonVirtualDtorChecker::DeleteBugVisitor::VisitNode(
const ExplodedNode *N, BugReporterContext &BRC,
BugReport &BR) {
const ExplodedNode *N, BugReporterContext &BRC, BugReport &BR) {
// Stop traversal after the first conversion was found on a path.
if (Satisfied)
return nullptr;

12
clang/lib/StaticAnalyzer/Checkers/DynamicTypeChecker.cpp
View File

@ -47,9 +47,9 @@ class DynamicTypeChecker : public Checker<check::PostStmt<ImplicitCastExpr>> {
ID.AddPointer(Reg);
}
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
private:
// The tracked region.
@ -88,10 +88,8 @@ void DynamicTypeChecker::reportTypeError(QualType DynamicType,
C.emitReport(std::move(R));
}
std::shared_ptr<PathDiagnosticPiece>
DynamicTypeChecker::DynamicTypeBugVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &) {
PathDiagnosticPieceRef DynamicTypeChecker::DynamicTypeBugVisitor::VisitNode(
const ExplodedNode *N, BugReporterContext &BRC, BugReport &) {
ProgramStateRef State = N->getState();
ProgramStateRef StatePrev = N->getFirstPred()->getState();

12
clang/lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp
View File

@ -83,9 +83,9 @@ class DynamicTypePropagation:
ID.AddPointer(Sym);
}
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
private:
// The tracked symbol.
@ -928,10 +928,8 @@ void DynamicTypePropagation::reportGenericsBug(
C.emitReport(std::move(R));
}
std::shared_ptr<PathDiagnosticPiece>
DynamicTypePropagation::GenericsBugVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) {
PathDiagnosticPieceRef DynamicTypePropagation::GenericsBugVisitor::VisitNode(
const ExplodedNode *N, BugReporterContext &BRC, BugReport &BR) {
ProgramStateRef state = N->getState();
ProgramStateRef statePrev = N->getFirstPred()->getState();

12
clang/lib/StaticAnalyzer/Checkers/InnerPointerChecker.cpp
View File

@ -54,9 +54,9 @@ public:
ID.AddPointer(getTag());
}
virtual std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
virtual PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
// FIXME: Scan the map once in the visitor's constructor and do a direct
// lookup by region.
@ -278,10 +278,8 @@ const MemRegion *getContainerObjRegion(ProgramStateRef State, SymbolRef Sym) {
} // end namespace ento
} // end namespace clang
std::shared_ptr<PathDiagnosticPiece>
InnerPointerChecker::InnerPointerBRVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &) {
PathDiagnosticPieceRef InnerPointerChecker::InnerPointerBRVisitor::VisitNode(
const ExplodedNode *N, BugReporterContext &BRC, BugReport &) {
if (!isSymbolTracked(N->getState(), PtrToBuf) ||
isSymbolTracked(N->getFirstPred()->getState(), PtrToBuf))
return nullptr;

10
clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp
View File

@ -120,12 +120,12 @@ class NonLocalizedStringBRVisitor final : public BugReporterVisitor {
public:
NonLocalizedStringBRVisitor(const MemRegion *NonLocalizedString)
: NonLocalizedString(NonLocalizedString), Satisfied(false) {
assert(NonLocalizedString);
assert(NonLocalizedString);
}
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *Succ,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *Succ,
BugReporterContext &BRC,
BugReport &BR) override;
void Profile(llvm::FoldingSetNodeID &ID) const override {
ID.Add(NonLocalizedString);
@ -998,7 +998,7 @@ void NonLocalizedStringChecker::checkPostStmt(const ObjCStringLiteral *SL,
setNonLocalizedState(sv, C);
}
std::shared_ptr<PathDiagnosticPiece>
PathDiagnosticPieceRef
NonLocalizedStringBRVisitor::VisitNode(const ExplodedNode *Succ,
BugReporterContext &BRC, BugReport &BR) {
if (Satisfied)

6
clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp
View File

@ -84,10 +84,8 @@ void MPIBugReporter::reportUnmatchedWait(
BReporter.emitReport(std::move(Report));
}
std::shared_ptr<PathDiagnosticPiece>
MPIBugReporter::RequestNodeVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) {
PathDiagnosticPieceRef MPIBugReporter::RequestNodeVisitor::VisitNode(
const ExplodedNode *N, BugReporterContext &BRC, BugReport &BR) {
if (IsNodeFound)
return nullptr;

6
clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.h
View File

@ -89,9 +89,9 @@ private:
ID.AddPointer(RequestRegion);
}
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
private:
const MemRegion *const RequestRegion;

8
clang/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp
View File

@ -139,9 +139,9 @@ private:
ID.AddPointer(Sym);
}
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
};
};
}
@ -613,7 +613,7 @@ ProgramStateRef MacOSKeychainAPIChecker::checkPointerEscape(
return State;
}
std::shared_ptr<PathDiagnosticPiece>
PathDiagnosticPieceRef
MacOSKeychainAPIChecker::SecKeychainBugVisitor::VisitNode(
const ExplodedNode *N, BugReporterContext &BRC, BugReport &BR) {
const AllocationState *AS = N->getState()->get<AllocatedData>(Sym);

22
clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp
View File

@ -516,19 +516,19 @@ private:
// released -> allocated, it must be the realloc return value
// check. If we have to handle more cases here, it might be cleaner just
// to track this extra bit in the state itself.
return ((!Stmt || !isa<CallExpr>(Stmt)) &&
(S && (S->isAllocated() || S->isAllocatedOfSizeZero())) &&
(SPrev && !(SPrev->isAllocated() ||
SPrev->isAllocatedOfSizeZero())));
return (
(!Stmt || !isa<CallExpr>(Stmt)) &&
(S && (S->isAllocated() || S->isAllocatedOfSizeZero())) &&
(SPrev && !(SPrev->isAllocated() || SPrev->isAllocatedOfSizeZero())));
}
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
std::shared_ptr<PathDiagnosticPiece>
getEndPath(BugReporterContext &BRC, const ExplodedNode *EndPathNode,
BugReport &BR) override {
PathDiagnosticPieceRef getEndPath(BugReporterContext &BRC,
const ExplodedNode *EndPathNode,
BugReport &BR) override {
if (!IsLeak)
return nullptr;
@ -2906,7 +2906,7 @@ static bool isReferenceCountingPointerDestructor(const CXXDestructorDecl *DD) {
return false;
}
std::shared_ptr<PathDiagnosticPiece> MallocChecker::MallocBugVisitor::VisitNode(
PathDiagnosticPieceRef MallocChecker::MallocBugVisitor::VisitNode(
const ExplodedNode *N, BugReporterContext &BRC, BugReport &BR) {
ProgramStateRef state = N->getState();

11
clang/lib/StaticAnalyzer/Checkers/MoveChecker.cpp
View File

@ -169,9 +169,9 @@ private:
// in the first place.
}
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
private:
const MoveChecker &Chk;
@ -270,9 +270,8 @@ static const MemRegion *unwrapRValueReferenceIndirection(const MemRegion *MR) {
return MR;
}
std::shared_ptr<PathDiagnosticPiece>
MoveChecker::MovedBugVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &BRC, BugReport &BR) {
PathDiagnosticPieceRef MoveChecker::MovedBugVisitor::VisitNode(
const ExplodedNode *N, BugReporterContext &BRC, BugReport &BR) {
// We need only the last move of the reported object's region.
// The visitor walks the ExplodedGraph backwards.
if (Found)

12
clang/lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp
View File

@ -137,9 +137,9 @@ private:
ID.AddPointer(Region);
}
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
private:
// The tracked region.
@ -290,10 +290,8 @@ NullabilityChecker::getTrackRegion(SVal Val, bool CheckSuperRegion) const {
return dyn_cast<SymbolicRegion>(Region);
}
std::shared_ptr<PathDiagnosticPiece>
NullabilityChecker::NullabilityBugVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) {
PathDiagnosticPieceRef NullabilityChecker::NullabilityBugVisitor::VisitNode(
const ExplodedNode *N, BugReporterContext &BRC, BugReport &BR) {
ProgramStateRef State = N->getState();
ProgramStateRef StatePrev = N->getFirstPred()->getState();

11
clang/lib/StaticAnalyzer/Checkers/ObjCSuperDeallocChecker.cpp
View File

@ -67,12 +67,11 @@ class SuperDeallocBRVisitor final : public BugReporterVisitor {
public:
SuperDeallocBRVisitor(SymbolRef ReceiverSymbol)
: ReceiverSymbol(ReceiverSymbol),
Satisfied(false) {}
: ReceiverSymbol(ReceiverSymbol), Satisfied(false) {}
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *Succ,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *Succ,
BugReporterContext &BRC,
BugReport &BR) override;
void Profile(llvm::FoldingSetNodeID &ID) const override {
ID.Add(ReceiverSymbol);
@ -243,7 +242,7 @@ ObjCSuperDeallocChecker::isSuperDeallocMessage(const ObjCMethodCall &M) const {
return M.getSelector() == SELdealloc;
}
std::shared_ptr<PathDiagnosticPiece>
PathDiagnosticPieceRef
SuperDeallocBRVisitor::VisitNode(const ExplodedNode *Succ,
BugReporterContext &BRC, BugReport &) {
if (Satisfied)

35
clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp
View File

@ -325,22 +325,22 @@ public:
ID.AddPointer(Sym);
}
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
std::shared_ptr<PathDiagnosticPiece> getEndPath(BugReporterContext &BRC,
const ExplodedNode *N,
BugReport &BR) override;
PathDiagnosticPieceRef getEndPath(BugReporterContext &BRC,
const ExplodedNode *N,
BugReport &BR) override;
};
class RefLeakReportVisitor : public RefCountReportVisitor {
public:
RefLeakReportVisitor(SymbolRef sym) : RefCountReportVisitor(sym) {}
std::shared_ptr<PathDiagnosticPiece> getEndPath(BugReporterContext &BRC,
const ExplodedNode *N,
BugReport &BR) override;
PathDiagnosticPieceRef getEndPath(BugReporterContext &BRC,
const ExplodedNode *N,
BugReport &BR) override;
};
} // end namespace retaincountchecker
@ -448,9 +448,9 @@ annotateStartParameter(const ExplodedNode *N, SymbolRef Sym,
return std::make_shared<PathDiagnosticEventPiece>(L, os.str());
}
std::shared_ptr<PathDiagnosticPiece>
RefCountReportVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &BRC, BugReport &BR) {
PathDiagnosticPieceRef RefCountReportVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) {
const auto &BT = static_cast<const RefCountBug&>(BR.getBugType());
const auto *Checker =
@ -709,21 +709,20 @@ static AllocationInfo GetAllocationSite(ProgramStateManager &StateMgr,
LeakContext)
FirstBinding = nullptr;
return AllocationInfo(AllocationNodeInCurrentOrParentContext,
FirstBinding,
return AllocationInfo(AllocationNodeInCurrentOrParentContext, FirstBinding,
InterestingMethodContext);
}
std::shared_ptr<PathDiagnosticPiece>
PathDiagnosticPieceRef
RefCountReportVisitor::getEndPath(BugReporterContext &BRC,
const ExplodedNode *EndN, BugReport &BR) {
const ExplodedNode *EndN, BugReport &BR) {
BR.markInteresting(Sym);
return BugReporterVisitor::getDefaultEndPath(BRC, EndN, BR);
}
std::shared_ptr<PathDiagnosticPiece>
PathDiagnosticPieceRef
RefLeakReportVisitor::getEndPath(BugReporterContext &BRC,
const ExplodedNode *EndN, BugReport &BR) {
const ExplodedNode *EndN, BugReport &BR) {
// Tell the BugReporterContext to report cases when the tracked symbol is
// assigned to different variables, etc.

6
clang/lib/StaticAnalyzer/Checkers/Taint.cpp
View File

@ -204,9 +204,9 @@ bool taint::isTainted(ProgramStateRef State, SymbolRef Sym, TaintTagType Kind) {
return false;
}
std::shared_ptr<PathDiagnosticPiece>
TaintBugVisitor::VisitNode(const ExplodedNode *N, BugReporterContext &BRC,
BugReport &BR) {
PathDiagnosticPieceRef TaintBugVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) {
// Find the ExplodedNode where the taint was first introduced
if (!isTainted(N->getState(), V) ||

6
clang/lib/StaticAnalyzer/Checkers/Taint.h
View File

@ -89,9 +89,9 @@ public:
TaintBugVisitor(const SVal V) : V(V) {}
void Profile(llvm::FoldingSetNodeID &ID) const override { ID.Add(V); }
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
};
} // namespace taint

12
clang/lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp
View File

@ -69,9 +69,9 @@ public:
ID.Add(SFC);
}
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *Succ,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *Succ,
BugReporterContext &BRC,
BugReport &BR) override;
};
class TestAfterDivZeroChecker
@ -92,9 +92,9 @@ public:
REGISTER_SET_WITH_PROGRAMSTATE(DivZeroMap, ZeroState)
std::shared_ptr<PathDiagnosticPiece>
DivisionBRVisitor::VisitNode(const ExplodedNode *Succ,
BugReporterContext &BRC, BugReport &BR) {
PathDiagnosticPieceRef DivisionBRVisitor::VisitNode(const ExplodedNode *Succ,
BugReporterContext &BRC,
BugReport &BR) {
if (Satisfied)
return nullptr;

20
clang/lib/StaticAnalyzer/Checkers/ValistChecker.cpp
View File

@ -77,20 +77,21 @@ private:
ID.AddPointer(&X);
ID.AddPointer(Reg);
}
std::shared_ptr<PathDiagnosticPiece>
getEndPath(BugReporterContext &BRC, const ExplodedNode *EndPathNode,
BugReport &BR) override {
PathDiagnosticPieceRef getEndPath(BugReporterContext &BRC,
const ExplodedNode *EndPathNode,
BugReport &BR) override {
if (!IsLeak)
return nullptr;
PathDiagnosticLocation L = PathDiagnosticLocation::createEndOfPath(
EndPathNode, BRC.getSourceManager());
// Do not add the statement itself as a range in case of leak.
return std::make_shared<PathDiagnosticEventPiece>(L, BR.getDescription(), false);
return std::make_shared<PathDiagnosticEventPiece>(L, BR.getDescription(),
false);
}
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
private:
const MemRegion *Reg;
@ -373,9 +374,8 @@ void ValistChecker::checkVAListEndCall(const CallEvent &Call,
C.addTransition(State);
}
std::shared_ptr<PathDiagnosticPiece> ValistChecker::ValistBugVisitor::VisitNode(
const ExplodedNode *N, BugReporterContext &BRC,
BugReport &) {
PathDiagnosticPieceRef ValistChecker::ValistBugVisitor::VisitNode(
const ExplodedNode *N, BugReporterContext &BRC, BugReport &) {
ProgramStateRef State = N->getState();
ProgramStateRef StatePrev = N->getFirstPred()->getState();

12
clang/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp
View File

@ -70,9 +70,9 @@ private:
ID.AddPointer(ObjectRegion);
}
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
};
};
} // end namespace
@ -80,10 +80,8 @@ private:
// GDM (generic data map) to the memregion of this for the ctor and dtor.
REGISTER_MAP_WITH_PROGRAMSTATE(CtorDtorMap, const MemRegion *, ObjectState)
std::shared_ptr<PathDiagnosticPiece>
VirtualCallChecker::VirtualBugVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &) {
PathDiagnosticPieceRef VirtualCallChecker::VirtualBugVisitor::VisitNode(
const ExplodedNode *N, BugReporterContext &BRC, BugReport &) {
// We need the last ctor/dtor which call the virtual function.
// The visitor walks the ExplodedGraph backwards.
if (Found)

20
clang/lib/StaticAnalyzer/Core/BugReporter.cpp
View File

@ -1881,12 +1881,11 @@ static void dropFunctionEntryEdge(PathPieces &Path, LocationContextMap &LCM,
Path.pop_front();
}
using VisitorsDiagnosticsTy = llvm::DenseMap<const ExplodedNode *,
std::vector<std::shared_ptr<PathDiagnosticPiece>>>;
using VisitorsDiagnosticsTy =
llvm::DenseMap<const ExplodedNode *, std::vector<PathDiagnosticPieceRef>>;
/// Populate executes lines with lines containing at least one diagnostics.
static void updateExecutedLinesWithDiagnosticPieces(
PathDiagnostic &PD) {
static void updateExecutedLinesWithDiagnosticPieces(PathDiagnostic &PD) {
PathPieces path = PD.path.flatten(/*ShouldFlattenMacros=*/true);
FilesToLineNumsMap &ExecutedLines = PD.getExecutedLines();
@ -1930,7 +1929,7 @@ static std::unique_ptr<PathDiagnostic> generatePathDiagnosticForConsumer(
if (GenerateDiagnostics) {
auto EndNotes = VisitorsDiagnostics.find(ErrorNode);
std::shared_ptr<PathDiagnosticPiece> LastPiece;
PathDiagnosticPieceRef LastPiece;
if (EndNotes != VisitorsDiagnostics.end()) {
assert(!EndNotes->second.empty());
LastPiece = EndNotes->second[0];
@ -1957,7 +1956,7 @@ static std::unique_ptr<PathDiagnostic> generatePathDiagnosticForConsumer(
std::set<llvm::FoldingSetNodeID> DeduplicationSet;
// Add pieces from custom visitors.
for (const auto &Note : VisitorNotes->second) {
for (const PathDiagnosticPieceRef &Note : VisitorNotes->second) {
llvm::FoldingSetNodeID ID;
Note->Profile(ID);
auto P = DeduplicationSet.insert(ID);
@ -2430,11 +2429,10 @@ BugPathInfo *BugPathGetter::getNextBugPath() {
/// object and collapses PathDiagosticPieces that are expanded by macros.
static void CompactMacroExpandedPieces(PathPieces &path,
const SourceManager& SM) {
using MacroStackTy =
std::vector<
std::pair<std::shared_ptr<PathDiagnosticMacroPiece>, SourceLocation>>;
using MacroStackTy = std::vector<
std::pair<std::shared_ptr<PathDiagnosticMacroPiece>, SourceLocation>>;
using PiecesTy = std::vector<std::shared_ptr<PathDiagnosticPiece>>;
using PiecesTy = std::vector<PathDiagnosticPieceRef>;
MacroStackTy MacroStack;
PiecesTy Pieces;
@ -2546,7 +2544,7 @@ generateVisitorsDiagnostics(BugReport *R, const ExplodedNode *ErrorNode,
const ExplodedNode *Pred = NextNode->getFirstPred();
if (!Pred) {
std::shared_ptr<PathDiagnosticPiece> LastPiece;
PathDiagnosticPieceRef LastPiece;
for (auto &V : visitors) {
V->finalizeVisitor(BRC, ErrorNode, *R);

131
clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp
View File

@ -255,20 +255,19 @@ static bool wasRegionOfInterestModifiedAt(const SubRegion *RegionOfInterest,
// Implementation of BugReporterVisitor.
//===----------------------------------------------------------------------===//
std::shared_ptr<PathDiagnosticPiece>
BugReporterVisitor::getEndPath(BugReporterContext &,
const ExplodedNode *, BugReport &) {
PathDiagnosticPieceRef BugReporterVisitor::getEndPath(BugReporterContext &,
const ExplodedNode *,
BugReport &) {
return nullptr;
}
void
BugReporterVisitor::finalizeVisitor(BugReporterContext &,
const ExplodedNode *, BugReport &) {}
void BugReporterVisitor::finalizeVisitor(BugReporterContext &,
const ExplodedNode *, BugReport &) {}
std::shared_ptr<PathDiagnosticPiece> BugReporterVisitor::getDefaultEndPath(
PathDiagnosticPieceRef BugReporterVisitor::getDefaultEndPath(
BugReporterContext &BRC, const ExplodedNode *EndPathNode, BugReport &BR) {
PathDiagnosticLocation L =
PathDiagnosticLocation::createEndOfPath(EndPathNode,BRC.getSourceManager());
PathDiagnosticLocation L = PathDiagnosticLocation::createEndOfPath(
EndPathNode, BRC.getSourceManager());
const auto &Ranges = BR.getRanges();
@ -333,9 +332,9 @@ public:
return static_cast<void *>(&Tag);
}
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BR,
BugReport &R) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BR,
BugReport &R) override;
private:
/// Attempts to find the region of interest in a given record decl,
@ -368,7 +367,7 @@ private:
/// either emit a note or suppress the report enirely.
/// \return Diagnostics piece for region not modified in the current function,
/// if it decides to emit one.
std::shared_ptr<PathDiagnosticPiece>
PathDiagnosticPieceRef
maybeEmitNote(BugReport &R, const CallEvent &Call, const ExplodedNode *N,
const RegionVector &FieldChain, const MemRegion *MatchedRegion,
StringRef FirstElement, bool FirstIsReferenceType,
@ -501,9 +500,9 @@ NoStoreFuncVisitor::findRegionOfInterestInRecord(
return None;
}
std::shared_ptr<PathDiagnosticPiece>
NoStoreFuncVisitor::VisitNode(const ExplodedNode *N, BugReporterContext &BR,
BugReport &R) {
PathDiagnosticPieceRef NoStoreFuncVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &BR,
BugReport &R) {
const LocationContext *Ctx = N->getLocationContext();
const StackFrameContext *SCtx = Ctx->getStackFrame();
@ -611,7 +610,7 @@ void NoStoreFuncVisitor::findModifyingFrames(const ExplodedNode *N) {
} while (N);
}
std::shared_ptr<PathDiagnosticPiece> NoStoreFuncVisitor::maybeEmitNote(
PathDiagnosticPieceRef NoStoreFuncVisitor::maybeEmitNote(
BugReport &R, const CallEvent &Call, const ExplodedNode *N,
const RegionVector &FieldChain, const MemRegion *MatchedRegion,
StringRef FirstElement, bool FirstIsReferenceType,
@ -752,13 +751,12 @@ class MacroNullReturnSuppressionVisitor final : public BugReporterVisitor {
bool WasModified = false;
public:
MacroNullReturnSuppressionVisitor(const SubRegion *R,
const SVal V) : RegionOfInterest(R),
ValueAtDereference(V) {}
MacroNullReturnSuppressionVisitor(const SubRegion *R, const SVal V)
: RegionOfInterest(R), ValueAtDereference(V) {}
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override {
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override {
if (WasModified)
return nullptr;
@ -956,9 +954,9 @@ public:
Options));
}
std::shared_ptr<PathDiagnosticPiece>
visitNodeInitial(const ExplodedNode *N,
BugReporterContext &BRC, BugReport &BR) {
PathDiagnosticPieceRef visitNodeInitial(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) {
// Only print a message at the interesting return statement.
if (N->getLocationContext() != StackFrame)
return nullptr;
@ -1059,9 +1057,9 @@ public:
return std::make_shared<PathDiagnosticEventPiece>(L, Out.str());
}
std::shared_ptr<PathDiagnosticPiece>
visitNodeMaybeUnsuppress(const ExplodedNode *N,
BugReporterContext &BRC, BugReport &BR) {
PathDiagnosticPieceRef visitNodeMaybeUnsuppress(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) {
#ifndef NDEBUG
assert(Options.ShouldAvoidSuppressingNullArgumentPaths);
#endif
@ -1108,9 +1106,9 @@ public:
return nullptr;
}
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override {
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override {
switch (Mode) {
case Initial:
return visitNodeInitial(N, BRC, BR);
@ -1291,7 +1289,7 @@ static void showBRDefaultDiagnostics(llvm::raw_svector_ostream& os,
}
}
std::shared_ptr<PathDiagnosticPiece>
PathDiagnosticPieceRef
FindLastStoreBRVisitor::VisitNode(const ExplodedNode *Succ,
BugReporterContext &BRC, BugReport &BR) {
if (Satisfied)
@ -1467,7 +1465,7 @@ bool TrackConstraintBRVisitor::isUnderconstrained(const ExplodedNode *N) const {
return (bool)N->getState()->assume(Constraint, !Assumption);
}
std::shared_ptr<PathDiagnosticPiece>
PathDiagnosticPieceRef
TrackConstraintBRVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &BRC, BugReport &) {
const ExplodedNode *PrevN = N->getFirstPred();
@ -1547,10 +1545,8 @@ const char *SuppressInlineDefensiveChecksVisitor::getTag() {
return "IDCVisitor";
}
std::shared_ptr<PathDiagnosticPiece>
SuppressInlineDefensiveChecksVisitor::VisitNode(const ExplodedNode *Succ,
BugReporterContext &BRC,
BugReport &BR) {
PathDiagnosticPieceRef SuppressInlineDefensiveChecksVisitor::VisitNode(
const ExplodedNode *Succ, BugReporterContext &BRC, BugReport &BR) {
const ExplodedNode *Pred = Succ->getFirstPred();
if (IsSatisfied)
return nullptr;
@ -1649,9 +1645,9 @@ public:
ID.AddPointer(&x);
}
std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) override;
};
} // end of anonymous namespace
@ -1687,10 +1683,8 @@ constructDebugPieceForTrackedCondition(const Expr *Cond,
(Twine() + "Tracking condition '" + ConditionText + "'").str());
}
std::shared_ptr<PathDiagnosticPiece>
TrackControlDependencyCondBRVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) {
PathDiagnosticPieceRef TrackControlDependencyCondBRVisitor::VisitNode(
const ExplodedNode *N, BugReporterContext &BRC, BugReport &BR) {
// We can only reason about control dependencies within the same stack frame.
if (Origin->getStackFrame() != N->getStackFrame())
return nullptr;
@ -1978,9 +1972,9 @@ const Expr *NilReceiverBRVisitor::getNilReceiver(const Stmt *S,
return nullptr;
}
std::shared_ptr<PathDiagnosticPiece>
NilReceiverBRVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &BRC, BugReport &BR) {
PathDiagnosticPieceRef NilReceiverBRVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) {
Optional<PreStmt> P = N->getLocationAs<PreStmt>();
if (!P)
return nullptr;
@ -2059,13 +2053,11 @@ void FindLastStoreBRVisitor::registerStatementVarDecls(BugReport &BR,
/// Return the tag associated with this visitor. This tag will be used
/// to make all PathDiagnosticPieces created by this visitor.
const char *ConditionBRVisitor::getTag() {
return "ConditionBRVisitor";
}
const char *ConditionBRVisitor::getTag() { return "ConditionBRVisitor"; }
std::shared_ptr<PathDiagnosticPiece>
ConditionBRVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &BRC, BugReport &BR) {
PathDiagnosticPieceRef ConditionBRVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) {
auto piece = VisitNodeImpl(N, BRC, BR);
if (piece) {
piece->setTag(getTag());
@ -2075,7 +2067,7 @@ ConditionBRVisitor::VisitNode(const ExplodedNode *N,
return piece;
}
std::shared_ptr<PathDiagnosticPiece>
PathDiagnosticPieceRef
ConditionBRVisitor::VisitNodeImpl(const ExplodedNode *N,
BugReporterContext &BRC, BugReport &BR) {
ProgramPoint ProgPoint = N->getLocation();
@ -2113,7 +2105,7 @@ ConditionBRVisitor::VisitNodeImpl(const ExplodedNode *N,
return nullptr;
}
std::shared_ptr<PathDiagnosticPiece> ConditionBRVisitor::VisitTerminator(
PathDiagnosticPieceRef ConditionBRVisitor::VisitTerminator(
const Stmt *Term, const ExplodedNode *N, const CFGBlock *srcBlk,
const CFGBlock *dstBlk, BugReport &R, BugReporterContext &BRC) {
const Expr *Cond = nullptr;
@ -2170,7 +2162,7 @@ std::shared_ptr<PathDiagnosticPiece> ConditionBRVisitor::VisitTerminator(
return VisitTrueTest(Cond, BRC, R, N, TookTrue);
}
std::shared_ptr<PathDiagnosticPiece>
PathDiagnosticPieceRef
ConditionBRVisitor::VisitTrueTest(const Expr *Cond, BugReporterContext &BRC,
BugReport &R, const ExplodedNode *N,
bool TookTrue) {
@ -2326,7 +2318,7 @@ bool ConditionBRVisitor::patternMatch(const Expr *Ex,
return false;
}
std::shared_ptr<PathDiagnosticPiece> ConditionBRVisitor::VisitTrueTest(
PathDiagnosticPieceRef ConditionBRVisitor::VisitTrueTest(
const Expr *Cond, const BinaryOperator *BExpr, BugReporterContext &BRC,
BugReport &R, const ExplodedNode *N, bool TookTrue, bool IsAssuming) {
bool shouldInvert = false;
@ -2441,7 +2433,7 @@ std::shared_ptr<PathDiagnosticPiece> ConditionBRVisitor::VisitTrueTest(
return event;
}
std::shared_ptr<PathDiagnosticPiece> ConditionBRVisitor::VisitConditionVariable(
PathDiagnosticPieceRef ConditionBRVisitor::VisitConditionVariable(
StringRef LhsString, const Expr *CondVarExpr, BugReporterContext &BRC,
BugReport &report, const ExplodedNode *N, bool TookTrue) {
// FIXME: If there's already a constraint tracker for this variable,
@ -2471,7 +2463,7 @@ std::shared_ptr<PathDiagnosticPiece> ConditionBRVisitor::VisitConditionVariable(
return event;
}
std::shared_ptr<PathDiagnosticPiece> ConditionBRVisitor::VisitTrueTest(
PathDiagnosticPieceRef ConditionBRVisitor::VisitTrueTest(
const Expr *Cond, const DeclRefExpr *DRE, BugReporterContext &BRC,
BugReport &report, const ExplodedNode *N, bool TookTrue, bool IsAssuming) {
const auto *VD = dyn_cast<VarDecl>(DRE->getDecl());
@ -2509,7 +2501,7 @@ std::shared_ptr<PathDiagnosticPiece> ConditionBRVisitor::VisitTrueTest(
return std::move(event);
}
std::shared_ptr<PathDiagnosticPiece> ConditionBRVisitor::VisitTrueTest(
PathDiagnosticPieceRef ConditionBRVisitor::VisitTrueTest(
const Expr *Cond, const MemberExpr *ME, BugReporterContext &BRC,
BugReport &report, const ExplodedNode *N, bool TookTrue, bool IsAssuming) {
SmallString<256> Buf;
@ -2677,9 +2669,9 @@ void LikelyFalsePositiveSuppressionBRVisitor::finalizeVisitor(
// Implementation of UndefOrNullArgVisitor.
//===----------------------------------------------------------------------===//
std::shared_ptr<PathDiagnosticPiece>
UndefOrNullArgVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &BRC, BugReport &BR) {
PathDiagnosticPieceRef UndefOrNullArgVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &BR) {
ProgramStateRef State = N->getState();
ProgramPoint ProgLoc = N->getLocation();
@ -2770,10 +2762,9 @@ void FalsePositiveRefutationBRVisitor::finalizeVisitor(
BR.markInvalid("Infeasible constraints", EndPathNode->getLocationContext());
}
std::shared_ptr<PathDiagnosticPiece>
PathDiagnosticPieceRef
FalsePositiveRefutationBRVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &,
BugReport &) {
BugReporterContext &, BugReport &) {
// Collect new constraints
const ConstraintRangeTy &NewCs = N->getState()->get<ConstraintRange>();
ConstraintRangeTy::Factory &CF =
@ -2807,9 +2798,9 @@ void TagVisitor::Profile(llvm::FoldingSetNodeID &ID) const {
ID.AddPointer(&Tag);
}
std::shared_ptr<PathDiagnosticPiece>
TagVisitor::VisitNode(const ExplodedNode *N, BugReporterContext &BRC,
BugReport &R) {
PathDiagnosticPieceRef TagVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
BugReport &R) {
ProgramPoint PP = N->getLocation();
const NoteTag *T = dyn_cast_or_null<NoteTag>(PP.getTag());
if (!T)

18
clang/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp
View File

@ -657,16 +657,14 @@ void HTMLDiagnostics::RewriteFile(Rewriter &R,
// Process the path.
// Maintain the counts of extra note pieces separately.
unsigned TotalPieces = path.size();
unsigned TotalNotePieces =
std::count_if(path.begin(), path.end(),
[](const std::shared_ptr<PathDiagnosticPiece> &p) {
return isa<PathDiagnosticNotePiece>(*p);
});
unsigned PopUpPieceCount =
std::count_if(path.begin(), path.end(),
[](const std::shared_ptr<PathDiagnosticPiece> &p) {
return isa<PathDiagnosticPopUpPiece>(*p);
});
unsigned TotalNotePieces = std::count_if(
path.begin(), path.end(), [](const PathDiagnosticPieceRef &p) {
return isa<PathDiagnosticNotePiece>(*p);
});
unsigned PopUpPieceCount = std::count_if(
path.begin(), path.end(), [](const PathDiagnosticPieceRef &p) {
return isa<PathDiagnosticPopUpPiece>(*p);
});
unsigned TotalRegularPieces = TotalPieces - TotalNotePieces - PopUpPieceCount;
unsigned NumRegularPieces = TotalRegularPieces;

14
clang/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp
View File

@ -479,16 +479,16 @@ static void printBugPath(llvm::raw_ostream &o, const FIDMap& FM,
const cross_tu::CrossTranslationUnitContext &CTU,
const PathPieces &Path) {
PlistPrinter Printer(FM, AnOpts, PP, CTU);
assert(std::is_partitioned(
Path.begin(), Path.end(),
[](const std::shared_ptr<PathDiagnosticPiece> &E)
{ return E->getKind() == PathDiagnosticPiece::Note; }) &&
assert(std::is_partitioned(Path.begin(), Path.end(),
[](const PathDiagnosticPieceRef &E) {
return E->getKind() == PathDiagnosticPiece::Note;
}) &&
"PathDiagnostic is not partitioned so that notes precede the rest");
PathPieces::const_iterator FirstNonNote = std::partition_point(
Path.begin(), Path.end(),
[](const std::shared_ptr<PathDiagnosticPiece> &E)
{ return E->getKind() == PathDiagnosticPiece::Note; });
Path.begin(), Path.end(), [](const PathDiagnosticPieceRef &E) {
return E->getKind() == PathDiagnosticPiece::Note;
});
PathPieces::const_iterator I = Path.begin();