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

[Szelethus]

Summary

Exactly what it says on the tin!

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

[NoQ]

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

All you need to know about the state of C++ refactoring tools.

clang/include/clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h

449–451

Mmm, why do we need to define this twice?

[xazax.hun]

Just wondering, did you check if we actually need shared ownership for this type? If not, do not waste your time checking for now :)

clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h

244

If you already touch these parts maybe you could capitalize some variable names.

clang/include/clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h

449–451

I agree, I would love to not to see it twice.

[Szelethus]

clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h

244

Hmm, okay, so, what is our stance on this? Apparently, LLVM changed the coding guideline, what would be the best direction moving forward?

clang/include/clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h

449–451

This file only forward declares classes from PathDiagnostic.h, so we do need this here.

clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h

 
 namespace ento {
 
 class BugReport;
 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 {
 public:
   BugReporterVisitor() = default;
   BugReporterVisitor(const BugReporterVisitor &) = default;
   BugReporterVisitor(BugReporterVisitor &&) {}
   virtual ~BugReporterVisitor();
 
   /// Return a diagnostic piece which should be associated with the
   /// given node.
   /// Note that this function does *not* get run on the very last node
   /// of the report, as the PathDiagnosticPiece associated with the
   /// last node should be unique.
   /// Use {@code getEndPath} to customize the note associated with the report
   /// end instead.
   ///
   /// 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.
   virtual void finalizeVisitor(BugReporterContext &BRC,
                                const ExplodedNode *EndPathNode,
                                BugReport &BR);
 
   /// Provide custom definition for the final diagnostic piece on the
   /// path - the piece, which is displayed before the path is expanded.
   ///
   /// 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,
+  static PathDiagnosticPieceRef getDefaultEndPath(BugReporterContext &BRC,
+                                                  const ExplodedNode *N,
                                                   BugReport &BR);
 };
 
 namespace bugreporter {
 
 /// Specifies the type of tracking for an expression.
 enum class TrackingKind {
   /// Default tracking kind -- specifies that as much information should be
   /// gathered about the tracked expression value as possible.
FindLastStoreBRVisitor(KnownSVal V, const MemRegion *R,
                          const StackFrameContext *OriginSFC = nullptr)
       : R(R), V(V), EnableNullFPSuppression(InEnableNullFPSuppression),
         TKind(TKind), OriginSFC(OriginSFC) {
     assert(R);
   }
 
   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,
 };
 
 class TrackConstraintBRVisitor final : public BugReporterVisitor {
   DefinedSVal Constraint;
   bool Assumption;
   bool IsSatisfied = false;
   bool IsZeroCheck;
 
   /// We should start tracking from the last node along the path in which the
   /// value is constrained.
   bool IsTrackingTurnedOn = false;
 
 public:
   TrackConstraintBRVisitor(DefinedSVal constraint, bool assumption)
       : Constraint(constraint), Assumption(assumption),
         IsZeroCheck(!Assumption && Constraint.getAs<Loc>()) {}
 
   void Profile(llvm::FoldingSetNodeID &ID) const override;
 
   /// Return the tag associated with this visitor.  This tag will be used
   /// 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,
 
 private:
   /// Checks if the constraint is valid in the current state.
   bool isUnderconstrained(const ExplodedNode *N) const;
 };
 
 /// \class NilReceiverBRVisitor
 /// Prints path notes when a message is sent to a nil receiver.
 class NilReceiverBRVisitor final : public BugReporterVisitor {
 public:
   void Profile(llvm::FoldingSetNodeID &ID) const override {
     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,
 
   /// If the statement is a message send expression with nil receiver, returns
   /// the receiver expression. Returns NULL otherwise.
   static const Expr *getNilReceiver(const Stmt *S, const ExplodedNode *N);
 };
 
 /// Visitor that tries to report interesting diagnostics from conditions.
 class ConditionBRVisitor final : public BugReporterVisitor {
   // FIXME: constexpr initialization isn't supported by MSVC2013.
   static const char *const GenericTrueMessage;
   static const char *const GenericFalseMessage;
 
 public:
   void Profile(llvm::FoldingSetNodeID &ID) const override {
     static int x = 0;
     ID.AddPointer(&x);
   }
 
   /// Return the tag associated with this visitor.  This tag will be used
   /// 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,
 
-  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,
+  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,
+  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);
-
-  std::shared_ptr<PathDiagnosticPiece>
-  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,
+  PathDiagnosticPieceRef VisitTrueTest(const Expr *Cond, const DeclRefExpr *DR,
+                                       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);
+
+  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);
 
   /// Tries to print the value of the given expression.
   ///
   /// \param CondVarExpr The expression to print its value.
   /// \param Out The stream to print.
static void *getTag() {
     static int Tag = 0;
     return static_cast<void *>(&Tag);
   }
 
   void Profile(llvm::FoldingSetNodeID &ID) const override {
     ID.AddPointer(getTag());
   }
 
-  std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *,
-                                                 BugReporterContext &,
-                                                 BugReport &) override {
+  PathDiagnosticPieceRef VisitNode(const ExplodedNode *, BugReporterContext &,
     return nullptr;
   }
 
   void finalizeVisitor(BugReporterContext &BRC, const ExplodedNode *N,
                        BugReport &BR) override;
 };
 
 /// When a region containing undefined value or '0' value is passed
public:
   UndefOrNullArgVisitor(const MemRegion *InR) : R(InR) {}
 
   void Profile(llvm::FoldingSetNodeID &ID) const override {
     static int Tag = 0;
     ID.AddPointer(&Tag);
     ID.AddPointer(R);
   }
 
-  std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
-                                                 BugReporterContext &BRC,
-                                                 BugReport &BR) override;
+  PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
 };
 
 class SuppressInlineDefensiveChecksVisitor final : public BugReporterVisitor {
   /// The symbolic value for which we are tracking constraints.
   /// This value is constrained to null in the end of path.
   DefinedSVal V;
 
   /// Track if we found the node where the constraint was first added.
public:
   SuppressInlineDefensiveChecksVisitor(DefinedSVal Val, const ExplodedNode *N);
 
   void Profile(llvm::FoldingSetNodeID &ID) const override;
 
   /// Return the tag associated with this visitor.  This tag will be used
   /// 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,
 };
 
 /// The bug visitor will walk all the nodes in a path and collect all the
 /// constraints. When it reaches the root node, will create a refutation
 /// manager and check if the constraints are satisfiable
 class FalsePositiveRefutationBRVisitor final : public BugReporterVisitor {
 private:
   /// Holds the constraints in a given path
   ConstraintRangeTy Constraints;
 
 public:
   FalsePositiveRefutationBRVisitor();
 
   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,
 
   void finalizeVisitor(BugReporterContext &BRC, const ExplodedNode *EndPathNode,
                        BugReport &BR) override;
 };
 
 
 /// The visitor detects NoteTags and displays the event notes they contain.
 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,
 };
 
 } // namespace ento
 
 } // namespace clang
 
 #endif // LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_BUGREPORTERVISITORS_H

clang/include/clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h

public:
 
   bool isLastInMainSourceFile() const {
     return LastInMainSourceFile;
   }
 
   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;
 
 public:
   PathPieces flatten(bool ShouldFlattenMacros) const {
     PathPieces Result;
     flattenTo(Result, Result, ShouldFlattenMacros);
     return Result;
public:
   /// Return the unrolled size of the path.
   unsigned full_size();
 
   void pushActivePath(PathPieces *p) { pathStack.push_back(p); }
   void popActivePath() { if (!pathStack.empty()) pathStack.pop_back(); }
 
   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");
     getActivePath().push_back(std::move(EndPiece));
   }
 
   void appendToDesc(StringRef S) {
     if (!ShortDesc.empty())

clang/lib/StaticAnalyzer/Checkers/DeleteWithNonVirtualDtorChecker.cpp

class DeleteWithNonVirtualDtorChecker
 
   class DeleteBugVisitor : public BugReporterVisitor {
   public:
     DeleteBugVisitor() : Satisfied(false) {}
     void Profile(llvm::FoldingSetNodeID &ID) const override {
       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,
 
   private:
     bool Satisfied;
   };
 
 public:
   void checkPreStmt(const CXXDeleteExpr *DE, CheckerContext &C) const;
 };
void DeleteWithNonVirtualDtorChecker::checkPreStmt(const CXXDeleteExpr *DE,
   auto R = llvm::make_unique<BugReport>(*BT, BT->getName(), N);
 
   // Mark region of problematic base class for later use in the BugVisitor.
   R->markInteresting(BaseClassRegion);
   R->addVisitor(llvm::make_unique<DeleteBugVisitor>());
   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;
 
   const Stmt *S = PathDiagnosticLocation::getStmt(N);
   if (!S)
     return nullptr;
 

clang/lib/StaticAnalyzer/Checkers/DynamicTypeChecker.cpp

public:
     DynamicTypeBugVisitor(const MemRegion *Reg) : Reg(Reg) {}
 
     void Profile(llvm::FoldingSetNodeID &ID) const override {
       static int X = 0;
       ID.AddPointer(&X);
       ID.AddPointer(Reg);
     }
 
-    std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
-                                                   BugReporterContext &BRC,
-                                                   BugReport &BR) override;
+    PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
 
   private:
     // The tracked region.
     const MemRegion *Reg;
   };
 
   void reportTypeError(QualType DynamicType, QualType StaticType,
                        const MemRegion *Reg, const Stmt *ReportedNode,
void DynamicTypeChecker::reportTypeError(QualType DynamicType,
   std::unique_ptr<BugReport> R(
       new BugReport(*BT, OS.str(), C.generateNonFatalErrorNode()));
   R->markInteresting(Reg);
   R->addVisitor(llvm::make_unique<DynamicTypeBugVisitor>(Reg));
   R->addRange(ReportedNode->getSourceRange());
   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();
 
   DynamicTypeInfo TrackedType = getDynamicTypeInfo(State, Reg);
   DynamicTypeInfo TrackedTypePrev = getDynamicTypeInfo(StatePrev, Reg);
   if (!TrackedType.isValid())
     return nullptr;
 

clang/lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp

public:
     GenericsBugVisitor(SymbolRef S) : Sym(S) {}
 
     void Profile(llvm::FoldingSetNodeID &ID) const override {
       static int X = 0;
       ID.AddPointer(&X);
       ID.AddPointer(Sym);
     }
 
-    std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
-                                                   BugReporterContext &BRC,
-                                                   BugReport &BR) override;
+    PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
 
   private:
     // The tracked symbol.
     SymbolRef Sym;
   };
 
   void reportGenericsBug(const ObjCObjectPointerType *From,
                          const ObjCObjectPointerType *To, ExplodedNode *N,
std::unique_ptr<BugReport> R(
       new BugReport(*ObjCGenericsBugType, OS.str(), N));
   R->markInteresting(Sym);
   R->addVisitor(llvm::make_unique<GenericsBugVisitor>(Sym));
   if (ReportedNode)
     R->addRange(ReportedNode->getSourceRange());
   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();
 
   const ObjCObjectPointerType *const *TrackedType =
       state->get<MostSpecializedTypeArgsMap>(Sym);
   const ObjCObjectPointerType *const *TrackedTypePrev =
       statePrev->get<MostSpecializedTypeArgsMap>(Sym);
   if (!TrackedType)

clang/lib/StaticAnalyzer/Checkers/InnerPointerChecker.cpp

static void *getTag() {
       static int Tag = 0;
       return &Tag;
     }
 
     void Profile(llvm::FoldingSetNodeID &ID) const override {
       ID.AddPointer(getTag());
     }
 
-    virtual std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
-                                                   BugReporterContext &BRC,
-                                                   BugReport &BR) override;
+    virtual PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
 
     // FIXME: Scan the map once in the visitor's constructor and do a direct
     // lookup by region.
     bool isSymbolTracked(ProgramStateRef State, SymbolRef Sym) {
       RawPtrMapTy Map = State->get<RawPtrMap>();
       for (const auto Entry : Map) {
         if (Entry.second.contains(Sym))
           return true;
const MemRegion *getContainerObjRegion(ProgramStateRef State, SymbolRef Sym) {
   }
   return nullptr;
 }
 
 } // end namespace allocation_state
 } // 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;
 
   const Stmt *S = PathDiagnosticLocation::getStmt(N);
   if (!S)
     return nullptr;
 

clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp

 class NonLocalizedStringBRVisitor final : public BugReporterVisitor {
 
   const MemRegion *NonLocalizedString;
   bool Satisfied;
 
 public:
   NonLocalizedStringBRVisitor(const MemRegion *NonLocalizedString)
       : NonLocalizedString(NonLocalizedString), Satisfied(false) {
-        assert(NonLocalizedString);
   }
 
-  std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *Succ,
-                                                 BugReporterContext &BRC,
-                                                 BugReport &BR) override;
+  PathDiagnosticPieceRef VisitNode(const ExplodedNode *Succ,
 
   void Profile(llvm::FoldingSetNodeID &ID) const override {
     ID.Add(NonLocalizedString);
   }
 };
 } // End anonymous namespace.
 
 #define NEW_RECEIVER(receiver)                                                 \

 
 /// Marks all empty string literals as localized
 void NonLocalizedStringChecker::checkPostStmt(const ObjCStringLiteral *SL,
                                               CheckerContext &C) const {
   SVal sv = C.getSVal(SL);
   setNonLocalizedState(sv, C);
 }
 
-std::shared_ptr<PathDiagnosticPiece>
+PathDiagnosticPieceRef
 NonLocalizedStringBRVisitor::VisitNode(const ExplodedNode *Succ,
                                        BugReporterContext &BRC, BugReport &BR) {
   if (Satisfied)
     return nullptr;
 
   Optional<StmtPoint> Point = Succ->getLocation().getAs<StmtPoint>();
   if (!Point.hasValue())
     return nullptr;

clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.h

RequestNodeVisitor(const MemRegion *const MemoryRegion,
         : RequestRegion(MemoryRegion), ErrorText(ErrText) {}
 
     void Profile(llvm::FoldingSetNodeID &ID) const override {
       static int X = 0;
       ID.AddPointer(&X);
       ID.AddPointer(RequestRegion);
     }
 
-    std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
-                                                   BugReporterContext &BRC,
-                                                   BugReport &BR) override;
+    PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
 
   private:
     const MemRegion *const RequestRegion;
     bool IsNodeFound = false;
     std::string ErrorText;
   };
 };
 
 } // end of namespace: mpi
 } // end of namespace: ento
 } // end of namespace: clang
 
 #endif

clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp

void MPIBugReporter::reportUnmatchedWait(
   Report->addRange(CE.getSourceRange());
   SourceRange Range = RequestRegion->sourceRange();
   if (Range.isValid())
     Report->addRange(Range);
 
   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;
 
   const Request *const Req = N->getState()->get<RequestMap>(RequestRegion);
   const Request *const PrevReq =
       N->getFirstPred()->getState()->get<RequestMap>(RequestRegion);
 

clang/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp

public:
     SecKeychainBugVisitor(SymbolRef S) : Sym(S) {}
 
     void Profile(llvm::FoldingSetNodeID &ID) const override {
       static int X = 0;
       ID.AddPointer(&X);
       ID.AddPointer(Sym);
     }
 
-    std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
-                                                   BugReporterContext &BRC,
-                                                   BugReport &BR) override;
+    PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
   };
 };
 }
 
 /// ProgramState traits to store the currently allocated (and not yet freed)
 /// symbols. This is a map from the allocated content symbol to the
 /// corresponding AllocationState.
 REGISTER_MAP_WITH_PROGRAMSTATE(AllocatedData,
if (const auto *SD = dyn_cast<SymbolDerived>(Sym)) {
       SymbolRef ParentSym = SD->getParentSymbol();
       if (Escaped.count(ParentSym))
         State = State->remove<AllocatedData>(Sym);
     }
   }
   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);
   if (!AS)
     return nullptr;
   const AllocationState *ASPrev =
       N->getFirstPred()->getState()->get<AllocatedData>(Sym);
   if (ASPrev)

clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp

public:
     }
 
     inline bool isReallocFailedCheck(const RefState *S, const RefState *SPrev,
                                      const Stmt *Stmt) {
       // If the expression is not a call, and the state change is
       // 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)) &&
+          (SPrev && !(SPrev->isAllocated() || SPrev->isAllocatedOfSizeZero())));
     }
 
-    std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
-                                                   BugReporterContext &BRC,
-                                                   BugReport &BR) override;
+    PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
 
-    std::shared_ptr<PathDiagnosticPiece>
-    getEndPath(BugReporterContext &BRC, const ExplodedNode *EndPathNode,
+    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(),
if (N.contains_lower("ptr") || N.contains_lower("pointer")) {
           N.contains_lower("intrusive") || N.contains_lower("shared")) {
         return true;
       }
     }
   }
   return false;
 }
 
-std::shared_ptr<PathDiagnosticPiece> MallocChecker::MallocBugVisitor::VisitNode(
+PathDiagnosticPieceRef MallocChecker::MallocBugVisitor::VisitNode(
     const ExplodedNode *N, BugReporterContext &BRC, BugReport &BR) {
 
   ProgramStateRef state = N->getState();
   ProgramStateRef statePrev = N->getFirstPred()->getState();
 
   const RefState *RS = state->get<RegionState>(Sym);
   const RefState *RSPrev = statePrev->get<RegionState>(Sym);
 

clang/lib/StaticAnalyzer/Checkers/MoveChecker.cpp

void Profile(llvm::FoldingSetNodeID &ID) const override {
       ID.AddPointer(&X);
       ID.AddPointer(Region);
       // Don't add RD because it's, in theory, uniquely determined by
       // the region. In practice though, it's not always possible to obtain
       // the declaration directly from the region, that's why we store it
       // in the first place.
     }
 
-    std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
-                                                   BugReporterContext &BRC,
-                                                   BugReport &BR) override;
+    PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
 
   private:
     const MoveChecker &Chk;
     // The tracked region.
     const MemRegion *Region;
     // The class of the tracked object.
     const CXXRecordDecl *RD;
     // How exactly the object was misused.
if (const auto *SR = dyn_cast_or_null<SymbolicRegion>(MR)) {
     SymbolRef Sym = SR->getSymbol();
     if (Sym->getType()->isRValueReferenceType())
       if (const MemRegion *OriginMR = Sym->getOriginRegion())
         return OriginMR;
   }
   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)
     return nullptr;
   ProgramStateRef State = N->getState();
   ProgramStateRef StatePrev = N->getFirstPred()->getState();
   const RegionState *TrackedObject = State->get<TrackedRegionMap>(Region);
   const RegionState *TrackedObjectPrev =

clang/lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp

public:
     NullabilityBugVisitor(const MemRegion *M) : Region(M) {}
 
     void Profile(llvm::FoldingSetNodeID &ID) const override {
       static int X = 0;
       ID.AddPointer(&X);
       ID.AddPointer(Region);
     }
 
-    std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
-                                                   BugReporterContext &BRC,
-                                                   BugReport &BR) override;
+    PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
 
   private:
     // The tracked region.
     const MemRegion *Region;
   };
 
   /// When any of the nonnull arguments of the analyzed function is null, do not
   /// report anything and turn off the check.
if (auto FieldReg = Region->getAs<FieldRegion>())
       return dyn_cast<SymbolicRegion>(FieldReg->getSuperRegion());
     if (auto ElementReg = Region->getAs<ElementRegion>())
       return dyn_cast<SymbolicRegion>(ElementReg->getSuperRegion());
   }
 
   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();
 
   const NullabilityState *TrackedNullab = State->get<NullabilityMap>(Region);
   const NullabilityState *TrackedNullabPrev =
       StatePrev->get<NullabilityMap>(Region);
   if (!TrackedNullab)
     return nullptr;

clang/lib/StaticAnalyzer/Checkers/ObjCSuperDeallocChecker.cpp

 
 namespace {
 class SuperDeallocBRVisitor final : public BugReporterVisitor {
   SymbolRef ReceiverSymbol;
   bool Satisfied;
 
 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,
 
   void Profile(llvm::FoldingSetNodeID &ID) const override {
     ID.Add(ReceiverSymbol);
   }
 };
 } // End anonymous namespace.
 
 void ObjCSuperDeallocChecker::checkPreObjCMessage(const ObjCMethodCall &M,
if (M.getOriginExpr()->getReceiverKind() != ObjCMessageExpr::SuperInstance)
     return false;
 
   ASTContext &Ctx = M.getState()->getStateManager().getContext();
   initIdentifierInfoAndSelectors(Ctx);
 
   return M.getSelector() == SELdealloc;
 }
 
-std::shared_ptr<PathDiagnosticPiece>
+PathDiagnosticPieceRef
 SuperDeallocBRVisitor::VisitNode(const ExplodedNode *Succ,
                                  BugReporterContext &BRC, BugReport &) {
   if (Satisfied)
     return nullptr;
 
   ProgramStateRef State = Succ->getState();
 
   bool CalledNow =

clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp

public:
   RefCountReportVisitor(SymbolRef sym) : Sym(sym) {}
 
   void Profile(llvm::FoldingSetNodeID &ID) const override {
     static int x = 0;
     ID.AddPointer(&x);
     ID.AddPointer(Sym);
   }
 
-  std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
-                                                 BugReporterContext &BRC,
-                                                 BugReport &BR) override;
+  PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
 
-  std::shared_ptr<PathDiagnosticPiece> getEndPath(BugReporterContext &BRC,
-                                                  const ExplodedNode *N,
-                                                  BugReport &BR) override;
+  PathDiagnosticPieceRef getEndPath(BugReporterContext &BRC,
 };
 
 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,
 };
 
 } // end namespace retaincountchecker
 } // end namespace ento
 } // end namespace clang
 
 
 /// Find the first node with the parent stack frame.
if (CurrT->getCount() == 1) {
     os << "1, as it is marked as consuming";
   } else {
     assert(CurrT->getCount() == 0);
     os << "0";
   }
   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 =
       static_cast<const RetainCountChecker *>(BT.getChecker());
 
   bool IsFreeUnowned = BT.getBugType() == RefCountBug::FreeNotOwned ||
                        BT.getBugType() == RefCountBug::DeallocNotOwned;
 
static AllocationInfo GetAllocationSite(ProgramStateManager &StateMgr,
   // do not report the binding.
   assert(N && "Could not find allocation node");
 
   if (AllocationNodeInCurrentOrParentContext &&
       AllocationNodeInCurrentOrParentContext->getLocationContext() !=
       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) {
   BR.markInteresting(Sym);
   return BugReporterVisitor::getDefaultEndPath(BRC, EndN, BR);
 }
 
-std::shared_ptr<PathDiagnosticPiece>
+PathDiagnosticPieceRef
 RefLeakReportVisitor::getEndPath(BugReporterContext &BRC,
-                                   const ExplodedNode *EndN, BugReport &BR) {
 
   // Tell the BugReporterContext to report cases when the tracked symbol is
   // assigned to different variables, etc.
   BR.markInteresting(Sym);
 
   // We are reporting a leak.  Walk up the graph to get to the first node where
   // the symbol appeared, and also get the first VarDecl that tracked object
   // is stored to.

clang/lib/StaticAnalyzer/Checkers/Taint.h

 class TaintBugVisitor final : public BugReporterVisitor {
 private:
   const SVal V;
 
 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,
 };
 
 } // namespace taint
 } // namespace ento
 } // namespace clang
 
 #endif
 

clang/lib/StaticAnalyzer/Checkers/Taint.cpp

if (const auto *SC = dyn_cast<SymbolCast>(*SI)) {
       if (isTainted(State, SC->getOperand(), Kind))
         return true;
     }
   }
 
   return false;
 }
 
-std::shared_ptr<PathDiagnosticPiece>
-TaintBugVisitor::VisitNode(const ExplodedNode *N, BugReporterContext &BRC,
+PathDiagnosticPieceRef TaintBugVisitor::VisitNode(const ExplodedNode *N,
+                                                  BugReporterContext &BRC,
                                                   BugReport &BR) {
 
   // Find the ExplodedNode where the taint was first introduced
   if (!isTainted(N->getState(), V) ||
       isTainted(N->getFirstPred()->getState(), V))
     return nullptr;
 
   const Stmt *S = PathDiagnosticLocation::getStmt(N);
   if (!S)

clang/lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp

public:
   DivisionBRVisitor(SymbolRef ZeroSymbol, const StackFrameContext *SFC)
       : ZeroSymbol(ZeroSymbol), SFC(SFC), Satisfied(false) {}
 
   void Profile(llvm::FoldingSetNodeID &ID) const override {
     ID.Add(ZeroSymbol);
     ID.Add(SFC);
   }
 
-  std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *Succ,
-                                                 BugReporterContext &BRC,
-                                                 BugReport &BR) override;
+  PathDiagnosticPieceRef VisitNode(const ExplodedNode *Succ,
 };
 
 class TestAfterDivZeroChecker
     : public Checker<check::PreStmt<BinaryOperator>, check::BranchCondition,
                      check::EndFunction> {
   mutable std::unique_ptr<BuiltinBug> DivZeroBug;
   void reportBug(SVal Val, CheckerContext &C) const;
 
 public:
   void checkPreStmt(const BinaryOperator *B, CheckerContext &C) const;
   void checkBranchCondition(const Stmt *Condition, CheckerContext &C) const;
   void checkEndFunction(const ReturnStmt *RS, CheckerContext &C) const;
   void setDivZeroMap(SVal Var, CheckerContext &C) const;
   bool hasDivZeroMap(SVal Var, const CheckerContext &C) const;
   bool isZero(SVal S, CheckerContext &C) const;
 };
 } // end anonymous namespace
 
 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;
 
   const Expr *E = nullptr;
 
   if (Optional<PostStmt> P = Succ->getLocationAs<PostStmt>())
     if (const BinaryOperator *BO = P->getStmtAs<BinaryOperator>()) {
       BinaryOperator::Opcode Op = BO->getOpcode();

clang/lib/StaticAnalyzer/Checkers/ValistChecker.cpp

private:
   public:
     ValistBugVisitor(const MemRegion *Reg, bool IsLeak = false)
         : Reg(Reg), IsLeak(IsLeak) {}
     void Profile(llvm::FoldingSetNodeID &ID) const override {
       static int X = 0;
       ID.AddPointer(&X);
       ID.AddPointer(Reg);
     }
-    std::shared_ptr<PathDiagnosticPiece>
-    getEndPath(BugReporterContext &BRC, const ExplodedNode *EndPathNode,
+    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,
 
   private:
     const MemRegion *Reg;
     bool IsLeak;
   };
 };
 
 const SmallVector<ValistChecker::VAListAccepter, 15>
reportUninitializedAccess(
         VAList, "va_end() is called on an uninitialized va_list", C);
     return;
   }
   ProgramStateRef State = C.getState();
   State = State->remove<InitializedVALists>(VAList);
   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();
 
   const Stmt *S = PathDiagnosticLocation::getStmt(N);
   if (!S)
     return nullptr;
 
   StringRef Msg;

clang/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp

public:
     VirtualBugVisitor(const MemRegion *R) : ObjectRegion(R), Found(false) {}
 
     void Profile(llvm::FoldingSetNodeID &ID) const override {
       static int X = 0;
       ID.AddPointer(&X);
       ID.AddPointer(ObjectRegion);
     }
 
-    std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
-                                                   BugReporterContext &BRC,
-                                                   BugReport &BR) override;
+    PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
   };
 };
 } // end namespace
 
 // 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)
     return nullptr;
 
   ProgramStateRef State = N->getState();
   const LocationContext *LCtx = N->getLocationContext();
   const CXXConstructorDecl *CD =

clang/lib/StaticAnalyzer/Core/BugReporter.cpp

static void dropFunctionEntryEdge(PathPieces &Path, LocationContextMap &LCM,
   const Decl *D = LCM[&Path]->getDecl();
   PathDiagnosticLocation EntryLoc = PathDiagnosticLocation::createBegin(D, SM);
   if (FirstEdge->getStartLocation() != EntryLoc)
     return;
 
   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();
 
   for (const auto &P : path) {
     FullSourceLoc Loc = P->getLocation().asLocation().getExpansionLoc();
     FileID FID = Loc.getFileID();
     unsigned LineNo = Loc.getLineNumber();
static std::unique_ptr<PathDiagnostic> generatePathDiagnosticForConsumer(
   AnalyzerOptions &Opts = PDB.getBugReporter().getAnalyzerOptions();
   StackDiagVector CallStack;
   InterestingExprs IE;
   LocationContextMap LCM;
   std::unique_ptr<PathDiagnostic> PD = generateEmptyDiagnosticForReport(R, SM);
 
   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];
     } else {
       LastPiece = BugReporterVisitor::getDefaultEndPath(PDB, ErrorNode, *R);
     }
     PD->setEndOfPath(LastPiece);
   }
while (NextNode) {
     if (!GenerateDiagnostics || VisitorNotes == VisitorsDiagnostics.end())
       continue;
 
     // This is a workaround due to inability to put shared PathDiagnosticPiece
     // into a FoldingSet.
     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);
       if (!P.second)
         continue;
 
       if (AddPathEdges)
         addEdgeToPath(PD->getActivePath(), PrevLoc, Note->getLocation());
BugPathInfo *BugPathGetter::getNextBugPath() {
 
   return &CurrentBugPath;
 }
 
 /// CompactMacroExpandedPieces - This function postprocesses a PathDiagnostic
 /// 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<
 
-  using PiecesTy = std::vector<std::shared_ptr<PathDiagnosticPiece>>;
+  using PiecesTy = std::vector<PathDiagnosticPieceRef>;
 
   MacroStackTy MacroStack;
   PiecesTy Pieces;
 
   for (PathPieces::const_iterator I = path.begin(), E = path.end();
        I != E; ++I) {
     const auto &piece = *I;
 
while (NextNode) {
     // a region at different points of the symbolic execution).
     for (std::unique_ptr<BugReporterVisitor> &Visitor : R->visitors())
       visitors.push_back(std::move(Visitor));
 
     R->clearVisitors();
 
     const ExplodedNode *Pred = NextNode->getFirstPred();
     if (!Pred) {
-      std::shared_ptr<PathDiagnosticPiece> LastPiece;
+      PathDiagnosticPieceRef LastPiece;
       for (auto &V : visitors) {
         V->finalizeVisitor(BRC, ErrorNode, *R);
 
         if (auto Piece = V->getEndPath(BRC, ErrorNode, *R)) {
           assert(!LastPiece &&
                  "There can only be one final piece in a diagnostic.");
           assert(Piece->getKind() == PathDiagnosticPiece::Kind::Event &&
                  "The final piece must contain a message!");

clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

static bool wasRegionOfInterestModifiedAt(const SubRegion *RegionOfInterest,
 
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // 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 &,
+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();
 
   // Only add the statement itself as a range if we didn't specify any
   // special ranges for this report.
   auto P = std::make_shared<PathDiagnosticEventPiece>(
       L, BR.getDescription(), Ranges.begin() == Ranges.end());
   for (SourceRange Range : Ranges)
void Profile(llvm::FoldingSetNodeID &ID) const override {
     ID.AddPointer(RegionOfInterest);
   }
 
   void *getTag() const {
     static int Tag = 0;
     return static_cast<void *>(&Tag);
   }
 
-  std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
-                                                 BugReporterContext &BR,
-                                                 BugReport &R) override;
+  PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
 
 private:
   /// Attempts to find the region of interest in a given record decl,
   /// by either following the base classes or fields.
   /// Dereferences fields up to a given recursion limit.
   /// Note that \p Vec is passed by value, leading to quadratic copying cost,
   /// but it's OK in practice since its length is limited to DEREFERENCE_LIMIT.
   /// \return A chain fields leading to the region of interest or None.
private:
   /// Write to \c FramesModifyingRegion all stack frames along
   /// the path in the current stack frame which modify \c RegionOfInterest.
   void findModifyingFrames(const ExplodedNode *N);
 
   /// Consume the information on the no-store stack frame in order to
   /// 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,
                 unsigned IndirectionLevel);
 
   /// Pretty-print region \p MatchedRegion to \p os.
   /// \return Whether printing succeeded.
   bool prettyPrintRegionName(StringRef FirstElement, bool FirstIsReferenceType,
if (const RecordDecl *RRD = PT->getAsRecordDecl())
       if (Optional<RegionVector> Out =
               findRegionOfInterestInRecord(RRD, State, VR, VecF, depth + 1))
         return Out;
   }
 
   return None;
 }
 
-std::shared_ptr<PathDiagnosticPiece>
-NoStoreFuncVisitor::VisitNode(const ExplodedNode *N, BugReporterContext &BR,
+PathDiagnosticPieceRef NoStoreFuncVisitor::VisitNode(const ExplodedNode *N,
+                                                     BugReporterContext &BR,
                                                      BugReport &R) {
 
   const LocationContext *Ctx = N->getLocationContext();
   const StackFrameContext *SCtx = Ctx->getStackFrame();
   ProgramStateRef State = N->getState();
   auto CallExitLoc = N->getLocationAs<CallExitBegin>();
 
   // No diagnostic if region was modified inside the frame.
   if (!CallExitLoc || isRegionOfInterestModifiedInFrame(N))
do {
 
     N = N->getFirstPred();
   } while (N);
 }
 
 static llvm::StringLiteral WillBeUsedForACondition =
     ", which will be (a part of a) condition";
 
-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,
     unsigned IndirectionLevel) {
   // Optimistically suppress uninitialized value bugs that result
   // from system headers having a chance to initialize the value
   // but failing to do so. It's too unlikely a system header's fault.
   // It's much more likely a situation in which the function has a failure
class MacroNullReturnSuppressionVisitor final : public BugReporterVisitor {
   const SubRegion *RegionOfInterest;
   const SVal ValueAtDereference;
 
   // Do not invalidate the reports where the value was modified
   // after it got assigned to from the macro.
   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,
     if (WasModified)
       return nullptr;
 
     auto BugPoint = BR.getErrorNode()->getLocation().getAs<StmtPoint>();
     if (!BugPoint)
       return nullptr;
 
     const SourceManager &SMgr = BRC.getSourceManager();
static void addVisitorIfNecessary(const ExplodedNode *Node, const Stmt *S,
     AnalyzerOptions &Options = State->getAnalysisManager().options;
 
     bool EnableNullFPSuppression = false;
     if (InEnableNullFPSuppression &&
         Options.ShouldSuppressNullReturnPaths)
       if (Optional<Loc> RetLoc = RetVal.getAs<Loc>())
         EnableNullFPSuppression = State->isNull(*RetLoc).isConstrainedTrue();
 
-    BR.addVisitor(llvm::make_unique<ReturnVisitor>(CalleeContext,
-                                                   EnableNullFPSuppression,
-                                                   Options, TKind));
+    BR.addVisitor(llvm::make_unique<ReturnVisitor>(
+        CalleeContext, EnableNullFPSuppression, Options, TKind));
   }
 
-  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() != CalleeSFC)
       return nullptr;
 
     Optional<StmtPoint> SP = N->getLocationAs<StmtPoint>();
     if (!SP)
       return nullptr;
 
PathDiagnosticPieceRef visitNodeInitial(const ExplodedNode *N,
     if (WouldEventBeMeaningless)
       EventPiece->setPrunable(true);
     else
       BR.markInteresting(CalleeSFC);
 
     return EventPiece;
   }
 
-  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
 
     // Are we at the entry node for this call?
     Optional<CallEnter> CE = N->getLocationAs<CallEnter>();
     if (!CE)
       return nullptr;
for (unsigned I = 0, E = Call->getNumArgs(); I != E; ++I) {
       // If we /can't/ track the null pointer, we should err on the side of
       // false negatives, and continue towards marking this report invalid.
       // (We will still look at the other arguments, though.)
     }
 
     return nullptr;
   }
 
-  std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
-                                                 BugReporterContext &BRC,
-                                                 BugReport &BR) override {
+  PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
     switch (Mode) {
     case Initial:
       return visitNodeInitial(N, BRC, BR);
     case MaybeUnsuppress:
       return visitNodeMaybeUnsuppress(N, BRC, BR);
     case Satisfied:
       return nullptr;
     }
static void showBRDefaultDiagnostics(llvm::raw_svector_ostream& os,
   }
 
   if (R->canPrintPretty()) {
     os << " to ";
     R->printPretty(os);
   }
 }
 
-std::shared_ptr<PathDiagnosticPiece>
+PathDiagnosticPieceRef
 FindLastStoreBRVisitor::VisitNode(const ExplodedNode *Succ,
                                   BugReporterContext &BRC, BugReport &BR) {
   if (Satisfied)
     return nullptr;
 
   const ExplodedNode *StoreSite = nullptr;
   const ExplodedNode *Pred = Succ->getFirstPred();
   const Expr *InitE = nullptr;

 }
 
 bool TrackConstraintBRVisitor::isUnderconstrained(const ExplodedNode *N) const {
   if (IsZeroCheck)
     return N->getState()->isNull(Constraint).isUnderconstrained();
   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();
   if (IsSatisfied)
     return nullptr;
 
   // Start tracking after we see the first state in which the value is
   // constrained.
void SuppressInlineDefensiveChecksVisitor::Profile(
   ID.AddPointer(&id);
   ID.Add(V);
 }
 
 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;
 
   // Start tracking after we see the first state in which the value is null.
   if (!IsTrackingTurnedOn)
     if (Succ->getState()->isNull(V).isConstrainedTrue())
       IsTrackingTurnedOn = true;
public:
   TrackControlDependencyCondBRVisitor(const ExplodedNode *O)
   : Origin(O), ControlDeps(&O->getCFG()) {}
 
   void Profile(llvm::FoldingSetNodeID &ID) const override {
     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,
 };
 } // end of anonymous namespace
 
 static std::shared_ptr<PathDiagnosticEventPiece>
 constructDebugPieceForTrackedCondition(const Expr *Cond,
                                        const ExplodedNode *N,
                                        BugReporterContext &BRC) {
 
static bool isAssertlikeBlock(const CFGBlock *B, ASTContext &Context) {
   // reached the end of the condition!
   if (const Stmt *ElseCond = Else->getTerminatorCondition())
     if (isa<BinaryOperator>(ElseCond))
       return isAssertlikeBlock(Else, Context);
 
   return false;
 }
 
-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;
 
   CFGBlock *NB = const_cast<CFGBlock *>(N->getCFGBlock());
 
   // Skip if we already inspected this block.
   if (!VisitedBlocks.insert(NB).second)
if (const Expr *Receiver = ME->getInstanceReceiver()) {
     ProgramStateRef state = N->getState();
     SVal V = N->getSVal(Receiver);
     if (state->isNull(V).isConstrainedTrue())
       return Receiver;
   }
   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;
 
   const Stmt *S = P->getStmt();
   const Expr *Receiver = getNilReceiver(S, N);
   if (!Receiver)
     return nullptr;

 }
 
 //===----------------------------------------------------------------------===//
 // Visitor that tries to report interesting diagnostics from conditions.
 //===----------------------------------------------------------------------===//
 
 /// 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());
     if (auto *ev = dyn_cast<PathDiagnosticEventPiece>(piece.get()))
       ev->setPrunable(true, /* override */ false);
   }
   return piece;
 }
 
-std::shared_ptr<PathDiagnosticPiece>
+PathDiagnosticPieceRef
 ConditionBRVisitor::VisitNodeImpl(const ExplodedNode *N,
                                   BugReporterContext &BRC, BugReport &BR) {
   ProgramPoint ProgPoint = N->getLocation();
   const std::pair<const ProgramPointTag *, const ProgramPointTag *> &Tags =
       ExprEngine::geteagerlyAssumeBinOpBifurcationTags();
 
   // If an assumption was made on a branch, it should be caught
   // here by looking at the state transition.
if (Optional<PostStmt> PS = ProgPoint.getAs<PostStmt>()) {
 
     bool TookTrue = CurrentNodeTag == Tags.first;
     return VisitTrueTest(cast<Expr>(PS->getStmt()), BRC, BR, N, TookTrue);
   }
 
   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;
 
   // In the code below, Term is a CFG terminator and Cond is a branch condition
   // expression upon which the decision is made on this terminator.
   //
   // For example, in "if (x == 0)", the "if (x == 0)" statement is a terminator,
PathDiagnosticPieceRef ConditionBRVisitor::VisitTerminator(
   }
 
   assert(Cond);
   assert(srcBlk->succ_size() == 2);
   const bool TookTrue = *(srcBlk->succ_begin()) == dstBlk;
   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) {
   ProgramStateRef CurrentState = N->getState();
   ProgramStateRef PrevState = N->getFirstPred()->getState();
   const LocationContext *LCtx = N->getLocationContext();
 
   // If the constraint information is changed between the current and the
else
                  CharSourceRange::getTokenRange(Ex->getSourceRange()),
                  BRC.getSourceManager(), BRC.getASTContext().getLangOpts(), 0)
           << '\'';
   }
 
   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;
   Optional<bool> shouldPrune;
 
   // Check if the field name of the MemberExprs is ambiguous. Example:
   // " 'a.d' is equal to 'h.d' " in 'test/Analysis/null-deref-path-notes.cpp'.
   bool IsSameFieldName = false;
if (!IsAssuming)
     return std::make_shared<PathDiagnosticPopUpPiece>(Loc, Message);
 
   auto event = std::make_shared<PathDiagnosticEventPiece>(Loc, Message);
   if (shouldPrune.hasValue())
     event->setPrunable(shouldPrune.getValue());
   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,
   // we shouldn't emit anything here (c.f. the double note in
   // test/Analysis/inlining/path-notes.c)
   SmallString<256> buf;
   llvm::raw_svector_ostream Out(buf);
   Out << "Assuming " << LhsString << " is ";
if (const auto *VD = dyn_cast<VarDecl>(DR->getDecl())) {
           event->setPrunable(false);
       }
     }
   }
 
   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());
   if (!VD)
     return nullptr;
 
   SmallString<256> Buf;
   llvm::raw_svector_ostream Out(Buf);
else {
       SVal V = state->getSVal(R);
       if (report.isInteresting(V))
         event->setPrunable(false);
     }
   }
   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;
   llvm::raw_svector_ostream Out(Buf);
 
   Out << (IsAssuming ? "Assuming field '" : "Field '")
       << ME->getMemberDecl()->getName() << "' is ";
 
while (Loc.isMacroID()) {
     }
   }
 }
 
 //===----------------------------------------------------------------------===//
 // 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();
 
   // We are only interested in visiting CallEnter nodes.
   Optional<CallEnter> CEnter = ProgLoc.getAs<CallEnter>();
   if (!CEnter)
     return nullptr;
 
void FalsePositiveRefutationBRVisitor::finalizeVisitor(
   Optional<bool> isSat = RefutationSolver->check();
   if (!isSat.hasValue())
     return;
 
   if (!isSat.getValue())
     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 =
       N->getState()->get_context<ConstraintRange>();
 
   // Add constraints if we don't have them yet
   for (auto const &C : NewCs) {
     const SymbolRef &Sym = C.first;

 
 int NoteTag::Kind = 0;
 
 void TagVisitor::Profile(llvm::FoldingSetNodeID &ID) const {
   static int Tag = 0;
   ID.AddPointer(&Tag);
 }
 
-std::shared_ptr<PathDiagnosticPiece>
-TagVisitor::VisitNode(const ExplodedNode *N, BugReporterContext &BRC,
+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)
     return nullptr;
 
   if (Optional<std::string> Msg = T->generateMessage(BRC, R)) {
     PathDiagnosticLocation Loc =
         PathDiagnosticLocation::create(PP, BRC.getSourceManager());
     auto Piece = std::make_shared<PathDiagnosticEventPiece>(Loc, *Msg);
     Piece->setPrunable(T->isPrunable());
     return Piece;
   }
 
   return nullptr;
 }

clang/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp

static void HandlePopUpPieceEndTag(Rewriter &R,
   }
 }
 
 void HTMLDiagnostics::RewriteFile(Rewriter &R,
                                   const PathPieces& path, FileID FID) {
   // 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) {
+  unsigned PopUpPieceCount = std::count_if(
+      path.begin(), path.end(), [](const PathDiagnosticPieceRef &p) {
 
   unsigned TotalRegularPieces = TotalPieces - TotalNotePieces - PopUpPieceCount;
   unsigned NumRegularPieces = TotalRegularPieces;
   unsigned NumNotePieces = TotalNotePieces;
   // Stores the count of the regular piece indices.
   std::map<int, int> IndexMap;
 
   // Stores the different ranges where we have reported something.

clang/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp

static void printCoverage(const PathDiagnostic *D,
   assert(IndentLevel == InputIndentLevel);
 }
 
 static void printBugPath(llvm::raw_ostream &o, const FIDMap& FM,
                          AnalyzerOptions &AnOpts,
                          const Preprocessor &PP,
                          const PathPieces &Path) {
   PlistPrinter Printer(FM, AnOpts, PP);
-  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();
 
   if (FirstNonNote != Path.begin()) {
     o << "   <key>notes</key>\n"
          "   <array>\n";
 
     for (; I != FirstNonNote; ++I)