[analyzer][NFC] Refactoring BugReporter.cpp P4.: If it can be const, make it const

[Szelethus]

Summary

When I'm new to a file/codebase, I personally find C++'s strong static type system to be a great aid. BugReporter.cpp is still painful to read however: function calls are made with mile long parameter lists, seemingly all of them taken with a non-const reference/pointer. This patch fixes nothing but this: make a few things const, and hammer it until it compiles.

[NoQ]

It's counter-idiomatic to pass manager objects (ProgramStateManager, SValBuilder, etc.) as const-references because it tells you pretty much nothing about what you can or cannot do with them. You don't really ever semantically mutate them in the first place. There's no need to mention it every time you pass them around.

But when it comes to actual data structures such as ExplodedGraph, we should totally be doing this, yeah :)

[baloghadamsoftware]

In D65382#1605572, @NoQ wrote:

It's counter-idiomatic to pass manager objects (ProgramStateManager, SValBuilder, etc.) as const-references because it tells you pretty much nothing about what you can or cannot do with them. You don't really ever semantically mutate them in the first place. There's no need to mention it every time you pass them around.

Most managers are stateful because they also store the elements they manage (e.g. ProgramStateManager stores states, SValBuilder owns other managers such as SymbolManager that stores symbols etc.) It is also true that BugReporter should not change the existing set of states, symbols etc., just use them in a read-only way. However, I see more confusion than help in making them const here and non-const elsewhere.

[NoQ]

In D65382#1605769, @baloghadamsoftware wrote:

Most managers are stateful because they also store the elements they manage (e.g. ProgramStateManager stores states, SValBuilder owns other managers such as SymbolManager that stores symbols etc.)

That's an implementation detail, a memoization, a good use case for mutable if we go for const-correctness. For example, no observable properties of SymbolManager change when it allocates a new symbol. The interface only allows you to ask "What's the symbol for a value-that-transcends-time with a certain identity?" and it retrieves you that symbol. There's no way to find out if the symbol is freshly created or already cached, and there shouldn't be a way to find this out, because this is entirely immaterial and meaningless.

[Szelethus]

Don't return ProgramStateManager and SValBuilder by const reference.

[NoQ]

Do it!

cfe/trunk/include/clang/Analysis/AnalysisDeclContext.h

public:
 
   CFG *getCFG() const { return getAnalysisDeclContext()->getCFG(); }
 
   template <typename T>
   T *getAnalysis() const {
     return getAnalysisDeclContext()->getAnalysis<T>();
   }
 
-  ParentMap &getParentMap() const {
+  const ParentMap &getParentMap() const {
     return getAnalysisDeclContext()->getParentMap();
   }
 
   const ImplicitParamDecl *getSelfDecl() const {
     return Ctx->getSelfDecl();
   }
 
   const StackFrameContext *getStackFrame() const;

cfe/trunk/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h

public:
   /// Disable all path pruning when generating a PathDiagnostic.
   void disablePathPruning() { DoNotPrunePath = true; }
 
   void markInteresting(SymbolRef sym);
   void markInteresting(const MemRegion *R);
   void markInteresting(SVal V);
   void markInteresting(const LocationContext *LC);
 
-  bool isInteresting(SymbolRef sym);
-  bool isInteresting(const MemRegion *R);
-  bool isInteresting(SVal V);
-  bool isInteresting(const LocationContext *LC);
+  bool isInteresting(SymbolRef sym) const;
+  bool isInteresting(const MemRegion *R) const;
+  bool isInteresting(SVal V) const;
+  bool isInteresting(const LocationContext *LC) const;
 
   /// Returns whether or not this report should be considered valid.
   ///
   /// Invalid reports are those that have been classified as likely false
   /// positives after the fact.
   bool isValid() const {
     return Invalidations.empty();
   }
public:
 
   /// Iterator over the set of BugReports tracked by the BugReporter.
   using EQClasses_iterator = llvm::FoldingSet<BugReportEquivClass>::iterator;
   EQClasses_iterator EQClasses_begin() { return EQClasses.begin(); }
   EQClasses_iterator EQClasses_end() { return EQClasses.end(); }
 
   ASTContext &getContext() { return D.getASTContext(); }
 
-  SourceManager &getSourceManager() { return D.getSourceManager(); }
+  const SourceManager &getSourceManager() { return D.getSourceManager(); }
 
-  AnalyzerOptions &getAnalyzerOptions() { return D.getAnalyzerOptions(); }
+  const AnalyzerOptions &getAnalyzerOptions() { return D.getAnalyzerOptions(); }
 
   virtual std::unique_ptr<DiagnosticForConsumerMapTy>
   generatePathDiagnostics(ArrayRef<PathDiagnosticConsumer *> consumers,
                           ArrayRef<BugReport *> &bugReports) {
     return {};
   }
 
   void Register(const BugType *BT);

 public:
   GRBugReporter(BugReporterData& d, ExprEngine& eng)
       : BugReporter(d, GRBugReporterKind), Eng(eng) {}
 
   ~GRBugReporter() override = default;;
 
   /// getGraph - Get the exploded graph created by the analysis engine
   ///  for the analyzed method or function.
-  ExplodedGraph &getGraph();
+  const ExplodedGraph &getGraph() const;
 
   /// getStateManager - Return the state manager used by the analysis
   ///  engine.
   ProgramStateManager &getStateManager();
 
+  ProgramStateManager &getStateManager() const;
+
   /// \p bugReports A set of bug reports within a *single* equivalence class
   ///
   /// \return A mapping from consumers to the corresponding diagnostics.
   /// Iterates through the bug reports within a single equivalence class,
   /// stops at a first non-invalidated report.
   std::unique_ptr<DiagnosticForConsumerMapTy>
   generatePathDiagnostics(ArrayRef<PathDiagnosticConsumer *> consumers,
                           ArrayRef<BugReport *> &bugReports) override;

 public:
   BugReporterContext(GRBugReporter &br, InterExplodedGraphMap &Backmap)
       : BR(br), NMC(Backmap) {}
 
   virtual ~BugReporterContext() = default;
 
   GRBugReporter& getBugReporter() { return BR; }
 
-  ExplodedGraph &getGraph() { return BR.getGraph(); }
+  const ExplodedGraph &getGraph() const { return BR.getGraph(); }
 
-  ProgramStateManager& getStateManager() {
+  ProgramStateManager& getStateManager() const {
     return BR.getStateManager();
   }
 
-  SValBuilder &getSValBuilder() {
+  SValBuilder &getSValBuilder() const {
     return getStateManager().getSValBuilder();
   }
 
-  ASTContext &getASTContext() {
+  ASTContext &getASTContext() const {
     return BR.getContext();
   }
 
-  SourceManager& getSourceManager() {
+  const SourceManager& getSourceManager() const {
     return BR.getSourceManager();
   }
 
-  AnalyzerOptions &getAnalyzerOptions() {
+  const AnalyzerOptions &getAnalyzerOptions() const {
     return BR.getAnalyzerOptions();
   }
 
   NodeMapClosure& getNodeResolver() { return NMC; }
 };
 
 
 /// The tag upon which the TagVisitor reacts. Add these in order to display

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

virtual void finalizeVisitor(BugReporterContext &BRC,
                                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 PathDiagnosticPieceRef
-  getEndPath(BugReporterContext &BRC, const ExplodedNode *N, BugReport &BR);
+  getEndPath(BugReporterContext &BRC, const ExplodedNode *N,
+             BugReport &BR);
 
   virtual void Profile(llvm::FoldingSetNodeID &ID) const = 0;
 
   /// Generates the default final diagnostic piece.
   static PathDiagnosticPieceRef getDefaultEndPath(BugReporterContext &BRC,
                                                   const ExplodedNode *N,
                                                   BugReport &BR);
 };

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

public:
   /// Profiles the diagnostic, including its path.
   ///
   /// Two diagnostics with the same issue along different paths will generate
   /// different profiles.
   void FullProfile(llvm::FoldingSetNodeID &ID) const;
 };
 
 } // namespace ento
-
 } // namespace clang
 
 #endif // LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_PATHDIAGNOSTIC_H

cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h

public:
 
   /// Return true if the current LocationContext has no caller context.
   bool inTopFrame() const { return getLocationContext()->inTopFrame();  }
 
   BugReporter &getBugReporter() {
     return Eng.getBugReporter();
   }
 
-  SourceManager &getSourceManager() {
+  const SourceManager &getSourceManager() {
     return getBugReporter().getSourceManager();
   }
 
   SValBuilder &getSValBuilder() {
     return Eng.getSValBuilder();
   }
 
   SymbolManager &getSymbolManager() {

cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h

public:
   const StackFrameContext *getStackFrame() const {
     return getLocation().getStackFrame();
   }
 
   const Decl &getCodeDecl() const { return *getLocationContext()->getDecl(); }
 
   CFG &getCFG() const { return *getLocationContext()->getCFG(); }
 
-  ParentMap &getParentMap() const {return getLocationContext()->getParentMap();}
+  const CFGBlock *getCFGBlock() const;
+
+  const ParentMap &getParentMap() const {
+    return getLocationContext()->getParentMap();
+  }
 
   template <typename T>
   T &getAnalysis() const {
     return *getLocationContext()->getAnalysis<T>();
   }
 
   const ProgramStateRef &getState() const { return State; }
 

cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h

public:
   BasicValueFactory &getBasicVals() {
     return svalBuilder->getBasicValueFactory();
   }
 
   SValBuilder &getSValBuilder() {
     return *svalBuilder;
   }
 
+  const SValBuilder &getSValBuilder() const {
+    return *svalBuilder;
+  }
+
   SymbolManager &getSymbolManager() {
     return svalBuilder->getSymbolManager();
   }
   const SymbolManager &getSymbolManager() const {
     return svalBuilder->getSymbolManager();
   }
 
   llvm::BumpPtrAllocator& getAllocator() { return Alloc; }

cfe/trunk/lib/StaticAnalyzer/Checkers/MallocChecker.cpp

 }
 
 void MallocChecker::processNewAllocation(const CXXNewExpr *NE,
                                          CheckerContext &C,
                                          SVal Target) const {
   if (!isStandardNewDelete(NE->getOperatorNew(), C.getASTContext()))
     return;
 
-  ParentMap &PM = C.getLocationContext()->getParentMap();
+  const ParentMap &PM = C.getLocationContext()->getParentMap();
   if (!PM.isConsumedExpr(NE) && treatUnusedNewEscaped(NE))
     return;
 
   ProgramStateRef State = C.getState();
   // The return value from operator new is bound to a specified initialization
   // value (if any) and we don't want to loose this value. So we call
   // MallocUpdateRefState() instead of MallocMemAux() which breaks the
   // existing binding.

cfe/trunk/lib/StaticAnalyzer/Checkers/ObjCUnusedIVarsChecker.cpp

if (const ObjCImplementationDecl *ID = dyn_cast<ObjCImplementationDecl>(D)) {
     for (const auto *Cat : ID->getClassInterface()->visible_categories()) {
       if (const ObjCCategoryImplDecl *CID = Cat->getImplementation())
         Scan(M, CID);
     }
   }
 }
 
 static void Scan(IvarUsageMap &M, const DeclContext *C, const FileID FID,
-                 SourceManager &SM) {
+                 const SourceManager &SM) {
   for (const auto *I : C->decls())
     if (const auto *FD = dyn_cast<FunctionDecl>(I)) {
       SourceLocation L = FD->getBeginLoc();
       if (SM.getFileID(L) == FID)
         Scan(M, FD->getBody());
     }
 }
 
static void checkObjCUnusedIvar(const ObjCImplementationDecl *D,
   if (!hasUnused)
     return;
 
   // We found some potentially unused ivars.  Scan the entire translation unit
   // for functions inside the @implementation that reference these ivars.
   // FIXME: In the future hopefully we can just use the lexical DeclContext
   // to go from the ObjCImplementationDecl to the lexically "nested"
   // C functions.
-  SourceManager &SM = BR.getSourceManager();
+  const SourceManager &SM = BR.getSourceManager();
   Scan(M, D->getDeclContext(), SM.getFileID(D->getLocation()), SM);
 
   // Find ivars that are unused.
   for (IvarUsageMap::iterator I = M.begin(), E = M.end(); I!=E; ++I)
     if (I->second == Unused) {
       std::string sbuf;
       llvm::raw_string_ostream os(sbuf);
       os << "Instance variable '" << *I->first << "' in class '" << *ID

cfe/trunk/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp

RefLeakReportVisitor::getEndPath(BugReporterContext &BRC,
   // 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.
   AllocationInfo AllocI = GetAllocationSite(BRC.getStateManager(), EndN, Sym);
 
   const MemRegion* FirstBinding = AllocI.R;
   BR.markInteresting(AllocI.InterestingMethodContext);
 
-  SourceManager& SM = BRC.getSourceManager();
+  const SourceManager& SM = BRC.getSourceManager();
 
   // Compute an actual location for the leak.  Sometimes a leak doesn't
   // occur at an actual statement (e.g., transition between blocks; end
   // of function) so we need to walk the graph and compute a real location.
   const ExplodedNode *LeakN = EndN;
   PathDiagnosticLocation L = PathDiagnosticLocation::createEndOfPath(LeakN, SM);
 
   std::string sbuf;

cfe/trunk/lib/StaticAnalyzer/Checkers/UnreachableCodeChecker.cpp

void UnreachableCodeChecker::checkEndAnalysis(ExplodedGraph &G,
                                               ExprEngine &Eng) const {
   CFGBlocksSet reachable, visited;
 
   if (Eng.hasWorkRemaining())
     return;
 
   const Decl *D = nullptr;
   CFG *C = nullptr;
-  ParentMap *PM = nullptr;
+  const ParentMap *PM = nullptr;
   const LocationContext *LC = nullptr;
   // Iterate over ExplodedGraph
   for (ExplodedGraph::node_iterator I = G.nodes_begin(), E = G.nodes_end();
       I != E; ++I) {
     const ProgramPoint &P = I->getLocation();
     LC = P.getLocationContext();
     if (!LC->inTopFrame())
       continue;

cfe/trunk/lib/StaticAnalyzer/Core/BugReporter.cpp

 /// A map from PathDiagnosticPiece to the LocationContext of the inlined
 /// function call it represents.
 using LocationContextMap =
     llvm::DenseMap<const PathPieces *, const LocationContext *>;
 
 /// Recursively scan through a path and prune out calls and macros pieces
 /// that aren't needed.  Return true if afterwards the path contains
 /// "interesting stuff" which means it shouldn't be pruned from the parent path.
-static bool removeUnneededCalls(PathPieces &pieces, BugReport *R,
-                                LocationContextMap &LCM,
+static bool removeUnneededCalls(PathPieces &pieces, const BugReport *R,
+                                const LocationContextMap &LCM,
                                 bool IsInteresting = false) {
   bool containsSomethingInteresting = IsInteresting;
   const unsigned N = pieces.size();
 
   for (unsigned i = 0 ; i < N ; ++i) {
     // Remove the front piece from the path.  If it is still something we
     // want to keep once we are done, we will push it back on the end.
     auto piece = std::move(pieces.front());
     pieces.pop_front();
 
     switch (piece->getKind()) {
       case PathDiagnosticPiece::Call: {
         auto &call = cast<PathDiagnosticCallPiece>(*piece);
         // Check if the location context is interesting.
         assert(LCM.count(&call.path));
         if (!removeUnneededCalls(call.path, R, LCM,
-                                 R->isInteresting(LCM[&call.path])))
+                                 R->isInteresting(LCM.lookup(&call.path))))
           continue;
 
         containsSomethingInteresting = true;
         break;
       }
       case PathDiagnosticPiece::Macro: {
         auto &macro = cast<PathDiagnosticMacroPiece>(*piece);
         if (!removeUnneededCalls(macro.subPieces, R, LCM, IsInteresting))

 //===----------------------------------------------------------------------===//
 // PathDiagnosticBuilder and its associated routines and helper objects.
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 class PathDiagnosticBuilder : public BugReporterContext {
   BugReport *R;
-  PathDiagnosticConsumer *PDC;
+  const PathDiagnosticConsumer *PDC;
 
 public:
   const LocationContext *LC;
 
   PathDiagnosticBuilder(GRBugReporter &br,
                         BugReport *r, InterExplodedGraphMap &Backmap,
-                        PathDiagnosticConsumer *pdc)
+                        const PathDiagnosticConsumer *pdc)
       : BugReporterContext(br, Backmap), R(r), PDC(pdc),
         LC(r->getErrorNode()->getLocationContext()) {}
 
-  PathDiagnosticLocation ExecutionContinues(const ExplodedNode *N);
+  PathDiagnosticLocation ExecutionContinues(const ExplodedNode *N) const;
 
   PathDiagnosticLocation ExecutionContinues(llvm::raw_string_ostream &os,
-                                            const ExplodedNode *N);
+                                            const ExplodedNode *N) const;
 
   BugReport *getBugReport() { return R; }
 
-  Decl const &getCodeDecl() { return R->getErrorNode()->getCodeDecl(); }
+  const Decl &getCodeDecl() const { return R->getErrorNode()->getCodeDecl(); }
 
-  ParentMap& getParentMap() { return LC->getParentMap(); }
+  const ParentMap& getParentMap() const { return LC->getParentMap(); }
 
-  const Stmt *getParent(const Stmt *S) {
+  const Stmt *getParent(const Stmt *S) const {
     return getParentMap().getParent(S);
   }
 
-  PathDiagnosticLocation getEnclosingStmtLocation(const Stmt *S);
+  PathDiagnosticLocation getEnclosingStmtLocation(const Stmt *S) const;
 
   PathDiagnosticConsumer::PathGenerationScheme getGenerationScheme() const {
     return PDC ? PDC->getGenerationScheme() : PathDiagnosticConsumer::Minimal;
   }
 
   bool supportsLogicalOpControlFlow() const {
     return PDC ? PDC->supportsLogicalOpControlFlow() : true;
   }
 };
 
 } // namespace
 
 PathDiagnosticLocation
-PathDiagnosticBuilder::ExecutionContinues(const ExplodedNode *N) {
+PathDiagnosticBuilder::ExecutionContinues(const ExplodedNode *N) const {
   if (const Stmt *S = PathDiagnosticLocation::getNextStmt(N))
     return PathDiagnosticLocation(S, getSourceManager(), LC);
 
   return PathDiagnosticLocation::createDeclEnd(N->getLocationContext(),
                                                getSourceManager());
 }
 
 PathDiagnosticLocation
 PathDiagnosticBuilder::ExecutionContinues(llvm::raw_string_ostream &os,
-                                          const ExplodedNode *N) {
+                                          const ExplodedNode *N) const {
   // Slow, but probably doesn't matter.
   if (os.str().empty())
     os << ' ';
 
   const PathDiagnosticLocation &Loc = ExecutionContinues(N);
 
   if (Loc.asStmt())
     os << "Execution continues on line "
static const Stmt *getEnclosingParent(const Stmt *S, const ParentMap &PM) {
   default:
     break;
   }
 
   return nullptr;
 }
 
 static PathDiagnosticLocation
-getEnclosingStmtLocation(const Stmt *S, SourceManager &SMgr, const ParentMap &P,
-                         const LocationContext *LC, bool allowNestedContexts) {
+getEnclosingStmtLocation(const Stmt *S, const SourceManager &SMgr,
+                         const ParentMap &P, const LocationContext *LC,
+                         bool allowNestedContexts) {
   if (!S)
     return {};
 
   while (const Stmt *Parent = getEnclosingParent(S, P)) {
     switch (Parent->getStmtClass()) {
       case Stmt::BinaryOperatorClass: {
         const auto *B = cast<BinaryOperator>(Parent);
         if (B->isLogicalOp())
getEnclosingStmtLocation(const Stmt *S, const SourceManager &SMgr,
   }
 
   assert(S && "Cannot have null Stmt for PathDiagnosticLocation");
 
   return PathDiagnosticLocation(S, SMgr, LC);
 }
 
 PathDiagnosticLocation
-PathDiagnosticBuilder::getEnclosingStmtLocation(const Stmt *S) {
+PathDiagnosticBuilder::getEnclosingStmtLocation(const Stmt *S) const {
   assert(S && "Null Stmt passed to getEnclosingStmtLocation");
   return ::getEnclosingStmtLocation(S, getSourceManager(), getParentMap(), LC,
                                     /*allowNestedContexts=*/false);
 }
 
 //===----------------------------------------------------------------------===//
 // "Minimal" path diagnostic generation algorithm.
 //===----------------------------------------------------------------------===//
 using StackDiagPair =
     std::pair<PathDiagnosticCallPiece *, const ExplodedNode *>;
 using StackDiagVector = SmallVector<StackDiagPair, 6>;
 
 static void updateStackPiecesWithMessage(PathDiagnosticPiece &P,
-                                         StackDiagVector &CallStack) {
+                                         const StackDiagVector &CallStack) {
   // If the piece contains a special message, add it to all the call
   // pieces on the active stack.
   if (auto *ep = dyn_cast<PathDiagnosticEventPiece>(&P)) {
     if (ep->hasCallStackHint())
       for (const auto &I : CallStack) {
         PathDiagnosticCallPiece *CP = I.first;
         const ExplodedNode *N = I.second;
         std::string stackMsg = ep->getCallStackMessage(N);
static void CompactMacroExpandedPieces(PathPieces &path,
                                        const SourceManager& SM);
 
 
 std::shared_ptr<PathDiagnosticControlFlowPiece> generateDiagForSwitchOP(
   const ExplodedNode *N,
   const CFGBlock *Dst,
   const SourceManager &SM,
   const LocationContext *LC,
-  PathDiagnosticBuilder &PDB,
+  const PathDiagnosticBuilder &PDB,
   PathDiagnosticLocation &Start
   ) {
   // Figure out what case arm we took.
   std::string sbuf;
   llvm::raw_string_ostream os(sbuf);
   PathDiagnosticLocation End;
 
   if (const Stmt *S = Dst->getLabel()) {
std::shared_ptr<PathDiagnosticControlFlowPiece> generateDiagForSwitchOP(
   }
   return std::make_shared<PathDiagnosticControlFlowPiece>(Start, End,
                                                        os.str());
 }
 
 
 std::shared_ptr<PathDiagnosticControlFlowPiece> generateDiagForGotoOP(
   const Stmt *S,
-  PathDiagnosticBuilder &PDB,
+  const PathDiagnosticBuilder &PDB,
   PathDiagnosticLocation &Start) {
     std::string sbuf;
     llvm::raw_string_ostream os(sbuf);
     const PathDiagnosticLocation &End = PDB.getEnclosingStmtLocation(S);
     os << "Control jumps to line " << End.asLocation().getExpansionLineNumber();
     return std::make_shared<PathDiagnosticControlFlowPiece>(Start, End, os.str());
 
 }
 
 std::shared_ptr<PathDiagnosticControlFlowPiece> generateDiagForBinaryOP(
-                                                 const ExplodedNode *N,
-                                                 const Stmt *T,
-                                                 const CFGBlock *Src,
-                                                 const CFGBlock *Dst,
-                                                 const SourceManager &SM,
-                                                 PathDiagnosticBuilder &PDB,
-                                                 const LocationContext *LC) {
+    const ExplodedNode *N, const Stmt *T, const CFGBlock *Src,
+    const CFGBlock *Dst, const SourceManager &SM,
+    const PathDiagnosticBuilder &PDB, const LocationContext *LC) {
+
   const auto *B = cast<BinaryOperator>(T);
   std::string sbuf;
   llvm::raw_string_ostream os(sbuf);
   os << "Left side of '";
   PathDiagnosticLocation Start, End;
 
   if (B->getOpcode() == BO_LAnd) {
     os << "&&"
if (B->getOpcode() == BO_LAnd) {
     }
   }
   return std::make_shared<PathDiagnosticControlFlowPiece>(Start, End,
                                                          os.str());
 }
 
 void generateMinimalDiagForBlockEdge(const ExplodedNode *N, BlockEdge BE,
                                      const SourceManager &SM,
-                                     PathDiagnosticBuilder &PDB,
+                                     const PathDiagnosticBuilder &PDB,
                                      PathDiagnostic &PD) {
   const LocationContext *LC = N->getLocationContext();
   const CFGBlock *Src = BE.getSrc();
   const CFGBlock *Dst = BE.getDst();
   const Stmt *T = Src->getTerminatorStmt();
   if (!T)
     return;
 

 }
 
 static bool isJumpToFalseBranch(const BlockEdge *BE) {
   const CFGBlock *Src = BE->getSrc();
   assert(Src->succ_size() == 2);
   return (*(Src->succ_begin()+1) == BE->getDst());
 }
 
-static bool isContainedByStmt(ParentMap &PM, const Stmt *S, const Stmt *SubS) {
+static bool isContainedByStmt(const ParentMap &PM, const Stmt *S,
+                              const Stmt *SubS) {
   while (SubS) {
     if (SubS == S)
       return true;
     SubS = PM.getParent(SubS);
   }
   return false;
 }
 
-static const Stmt *getStmtBeforeCond(ParentMap &PM, const Stmt *Term,
+static const Stmt *getStmtBeforeCond(const ParentMap &PM, const Stmt *Term,
                                      const ExplodedNode *N) {
   while (N) {
     Optional<StmtPoint> SP = N->getLocation().getAs<StmtPoint>();
     if (SP) {
       const Stmt *S = SP->getStmt();
       if (!isContainedByStmt(PM, Term, S))
         return S;
     }
     N = N->getFirstPred();
   }
   return nullptr;
 }
 
-static bool isInLoopBody(ParentMap &PM, const Stmt *S, const Stmt *Term) {
+static bool isInLoopBody(const ParentMap &PM, const Stmt *S, const Stmt *Term) {
   const Stmt *LoopBody = nullptr;
   switch (Term->getStmtClass()) {
     case Stmt::CXXForRangeStmtClass: {
       const auto *FR = cast<CXXForRangeStmt>(Term);
       if (isContainedByStmt(PM, FR->getInc(), S))
         return true;
       if (isContainedByStmt(PM, FR->getLoopVarStmt(), S))
         return true;

 /// which returns the element for ObjCForCollectionStmts.
 static const Stmt *getTerminatorCondition(const CFGBlock *B) {
   const Stmt *S = B->getTerminatorCondition();
   if (const auto *FS = dyn_cast_or_null<ObjCForCollectionStmt>(S))
     return FS->getElement();
   return S;
 }
 
-static const char StrEnteringLoop[] = "Entering loop body";
-static const char StrLoopBodyZero[] = "Loop body executed 0 times";
-static const char StrLoopRangeEmpty[] =
-  "Loop body skipped when range is empty";
-static const char StrLoopCollectionEmpty[] =
+llvm::StringLiteral StrEnteringLoop = "Entering loop body";
+llvm::StringLiteral StrLoopBodyZero = "Loop body executed 0 times";
+llvm::StringLiteral StrLoopRangeEmpty = "Loop body skipped when range is empty";
+llvm::StringLiteral StrLoopCollectionEmpty =
     "Loop body skipped when collection is empty";
 
 static std::unique_ptr<FilesToLineNumsMap>
-findExecutedLines(SourceManager &SM, const ExplodedNode *N);
+findExecutedLines(const SourceManager &SM, const ExplodedNode *N);
 
 /// Generate diagnostics for the node \p N,
 /// and write it into \p PD.
 /// \p AddPathEdges Whether diagnostic consumer can generate path arrows
 /// showing both row and column.
 static void generatePathDiagnosticsForNode(const ExplodedNode *N,
       PathDiagnostic &PD,
       PathDiagnosticLocation &PrevLoc,
if (const Stmt *Loop = BE->getSrc()->getLoopTarget()) {
 
       if (const auto *CS = dyn_cast_or_null<CompoundStmt>(Body)) {
         addEdgeToPath(PD.getActivePath(), PrevLoc,
             PathDiagnosticLocation::createEndBrace(CS, SM));
       }
     }
 
     const CFGBlock *BSrc = BE->getSrc();
-    ParentMap &PM = PDB.getParentMap();
+    const ParentMap &PM = PDB.getParentMap();
 
     if (const Stmt *Term = BSrc->getTerminatorStmt()) {
       // Are we jumping past the loop body without ever executing the
       // loop (because the condition was false)?
       if (isLoop(Term)) {
         const Stmt *TermCond = getTerminatorCondition(BSrc);
         bool IsInLoopBody =
           isInLoopBody(PM, getStmtBeforeCond(PM, TermCond, N), Term);
 
-        const char *str = nullptr;
+        StringRef str;
 
         if (isJumpToFalseBranch(&*BE)) {
           if (!IsInLoopBody) {
             if (isa<ObjCForCollectionStmt>(Term)) {
               str = StrLoopCollectionEmpty;
             } else if (isa<CXXForRangeStmt>(Term)) {
               str = StrLoopRangeEmpty;
             } else {
               str = StrLoopBodyZero;
             }
           }
         } else {
           str = StrEnteringLoop;
         }
 
-        if (str) {
+        if (!str.empty()) {
           PathDiagnosticLocation L(TermCond ? TermCond : Term, SM, PDB.LC);
           auto PE = std::make_shared<PathDiagnosticEventPiece>(L, str);
           PE->setPrunable(true);
           addEdgeToPath(PD.getActivePath(), PrevLoc,
               PE->getLocation());
           PD.getActivePath().push_front(std::move(PE));
         }
       } else if (isa<BreakStmt>(Term) || isa<ContinueStmt>(Term) ||
           isa<GotoStmt>(Term)) {
         PathDiagnosticLocation L(Term, SM, PDB.LC);
         addEdgeToPath(PD.getActivePath(), PrevLoc, L);
       }
     }
   }
 }
 
 static std::unique_ptr<PathDiagnostic>
-generateEmptyDiagnosticForReport(BugReport *R, SourceManager &SM) {
+generateEmptyDiagnosticForReport(const BugReport *R, const SourceManager &SM) {
   const BugType &BT = R->getBugType();
   return llvm::make_unique<PathDiagnostic>(
       R->getBugType().getCheckName(), R->getDeclWithIssue(),
       R->getBugType().getName(), R->getDescription(),
       R->getShortDescription(/*UseFallback=*/false), BT.getCategory(),
       R->getUniqueingLocation(), R->getUniqueingDecl(),
       findExecutedLines(SM, R->getErrorNode()));
 }

 
 using OptimizedCallsSet = llvm::DenseSet<const PathDiagnosticCallPiece *>;
 
 /// Adds synthetic edges from top-level statements to their subexpressions.
 ///
 /// This avoids a "swoosh" effect, where an edge from a top-level statement A
 /// points to a sub-expression B.1 that's not at the start of B. In these cases,
 /// we'd like to see an edge from A to B, then another one from B to B.1.
-static void addContextEdges(PathPieces &pieces, SourceManager &SM,
+static void addContextEdges(PathPieces &pieces, const SourceManager &SM,
                             const ParentMap &PM, const LocationContext *LCtx) {
   PathPieces::iterator Prev = pieces.end();
   for (PathPieces::iterator I = pieces.begin(), E = Prev; I != E;
        Prev = I, ++I) {
     auto *Piece = dyn_cast<PathDiagnosticControlFlowPiece>(I->get());
 
     if (!Piece)
       continue;
static void simplifySimpleBranches(PathPieces &pieces) {
   }
 }
 
 /// Returns the number of bytes in the given (character-based) SourceRange.
 ///
 /// If the locations in the range are not on the same line, returns None.
 ///
 /// Note that this does not do a precise user-visible character or column count.
-static Optional<size_t> getLengthOnSingleLine(SourceManager &SM,
+static Optional<size_t> getLengthOnSingleLine(const SourceManager &SM,
                                               SourceRange Range) {
   SourceRange ExpansionRange(SM.getExpansionLoc(Range.getBegin()),
                              SM.getExpansionRange(Range.getEnd()).getEnd());
 
   FileID FID = SM.getFileID(ExpansionRange.getBegin());
   if (FID != SM.getFileID(ExpansionRange.getEnd()))
     return None;
 
static Optional<size_t> getLengthOnSingleLine(const SourceManager &SM,
   if (Snippet.find_first_of("\r\n") != StringRef::npos)
     return None;
 
   // This isn't Unicode-aware, but it doesn't need to be.
   return Snippet.size();
 }
 
 /// \sa getLengthOnSingleLine(SourceManager, SourceRange)
-static Optional<size_t> getLengthOnSingleLine(SourceManager &SM,
+static Optional<size_t> getLengthOnSingleLine(const SourceManager &SM,
                                               const Stmt *S) {
   return getLengthOnSingleLine(SM, S->getSourceRange());
 }
 
 /// Eliminate two-edge cycles created by addContextEdges().
 ///
 /// Once all the context edges are in place, there are plenty of cases where
 /// there's a single edge from a top-level statement to a subexpression,
 /// followed by a single path note, and then a reverse edge to get back out to
 /// the top level. If the statement is simple enough, the subexpression edges
 /// just add noise and make it harder to understand what's going on.
 ///
 /// This function only removes edges in pairs, because removing only one edge
 /// might leave other edges dangling.
 ///
 /// This will not remove edges in more complicated situations:
 /// - if there is more than one "hop" leading to or from a subexpression.
 /// - if there is an inlined call between the edges instead of a single event.
 /// - if the whole statement is large enough that having subexpression arrows
 ///   might be helpful.
-static void removeContextCycles(PathPieces &Path, SourceManager &SM) {
+static void removeContextCycles(PathPieces &Path, const SourceManager &SM) {
   for (PathPieces::iterator I = Path.begin(), E = Path.end(); I != E; ) {
     // Pattern match the current piece and its successor.
     const auto *PieceI = dyn_cast<PathDiagnosticControlFlowPiece>(I->get());
 
     if (!PieceI) {
       ++I;
       continue;
     }
if (s1Start && s2Start && s1Start == s2End && s2Start == s1End) {
       }
     }
 
     ++I;
   }
 }
 
 /// Return true if X is contained by Y.
-static bool lexicalContains(ParentMap &PM, const Stmt *X, const Stmt *Y) {
+static bool lexicalContains(const ParentMap &PM, const Stmt *X, const Stmt *Y) {
   while (X) {
     if (X == Y)
       return true;
     X = PM.getParent(X);
   }
   return false;
 }
 
 // Remove short edges on the same line less than 3 columns in difference.
-static void removePunyEdges(PathPieces &path, SourceManager &SM,
-                            ParentMap &PM) {
+static void removePunyEdges(PathPieces &path, const SourceManager &SM,
+                            const ParentMap &PM) {
   bool erased = false;
 
   for (PathPieces::iterator I = path.begin(), E = path.end(); I != E;
        erased ? I : ++I) {
     erased = false;
 
     const auto *PieceI = dyn_cast<PathDiagnosticControlFlowPiece>(I->get());
 
for (PathPieces::iterator I = path.begin(), E = path.end(); I != E; ++I) {
 
     // Erase the second piece if it has the same exact message text.
     if (PieceI->getString() == PieceNextI->getString()) {
       path.erase(NextI);
     }
   }
 }
 
-static bool optimizeEdges(PathPieces &path, SourceManager &SM,
+static bool optimizeEdges(PathPieces &path, const SourceManager &SM,
                           OptimizedCallsSet &OCS,
-                          LocationContextMap &LCM) {
+                          const LocationContextMap &LCM) {
   bool hasChanges = false;
-  const LocationContext *LC = LCM[&path];
+  const LocationContext *LC = LCM.lookup(&path);
   assert(LC);
-  ParentMap &PM = LC->getParentMap();
+  const ParentMap &PM = LC->getParentMap();
 
   for (PathPieces::iterator I = path.begin(), E = path.end(); I != E; ) {
     // Optimize subpaths.
     if (auto *CallI = dyn_cast<PathDiagnosticCallPiece>(I->get())) {
       // Record the fact that a call has been optimized so we only do the
       // effort once.
       if (!OCS.count(CallI)) {
         while (optimizeEdges(CallI->path, SM, OCS, LCM)) {}

 }
 
 /// Drop the very first edge in a path, which should be a function entry edge.
 ///
 /// If the first edge is not a function entry edge (say, because the first
 /// statement had an invalid source location), this function does nothing.
 // FIXME: We should just generate invalid edges anyway and have the optimizer
 // deal with them.
-static void dropFunctionEntryEdge(PathPieces &Path, LocationContextMap &LCM,
-                                  SourceManager &SM) {
+static void dropFunctionEntryEdge(PathPieces &Path,
+                                  const LocationContextMap &LCM,
+                                  const SourceManager &SM) {
   const auto *FirstEdge =
       dyn_cast<PathDiagnosticControlFlowPiece>(Path.front().get());
   if (!FirstEdge)
     return;
 
-  const Decl *D = LCM[&Path]->getDecl();
+  const Decl *D = LCM.lookup(&Path)->getDecl();
   PathDiagnosticLocation EntryLoc = PathDiagnosticLocation::createBegin(D, SM);
   if (FirstEdge->getStartLocation() != EntryLoc)
     return;
 
   Path.pop_front();
 }
 
 using VisitorsDiagnosticsTy =

 static std::unique_ptr<PathDiagnostic> generatePathDiagnosticForConsumer(
     PathDiagnosticConsumer::PathGenerationScheme ActiveScheme,
     PathDiagnosticBuilder &PDB,
     const ExplodedNode *ErrorNode,
     const VisitorsDiagnosticsTy &VisitorsDiagnostics) {
 
   bool GenerateDiagnostics = (ActiveScheme != PathDiagnosticConsumer::None);
   bool AddPathEdges = (ActiveScheme == PathDiagnosticConsumer::Extensive);
-  SourceManager &SM = PDB.getSourceManager();
-  BugReport *R = PDB.getBugReport();
-  AnalyzerOptions &Opts = PDB.getBugReporter().getAnalyzerOptions();
+  const SourceManager &SM = PDB.getSourceManager();
+  const BugReport *R = PDB.getBugReport();
+  const 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);
     PathDiagnosticPieceRef LastPiece;
     if (EndNotes != VisitorsDiagnostics.end()) {
       assert(!EndNotes->second.empty());
       LastPiece = EndNotes->second[0];
     } else {
-      LastPiece = BugReporterVisitor::getDefaultEndPath(PDB, ErrorNode, *R);
+      LastPiece = BugReporterVisitor::getDefaultEndPath(PDB, ErrorNode,
+                                                        *PDB.getBugReport());
     }
     PD->setEndOfPath(LastPiece);
   }
 
   PathDiagnosticLocation PrevLoc = PD->getLocation();
   const ExplodedNode *NextNode = ErrorNode->getFirstPred();
   while (NextNode) {
     if (GenerateDiagnostics)
       generatePathDiagnosticsForNode(
           NextNode, *PD, PrevLoc, PDB, LCM, CallStack, IE, AddPathEdges);
 
     auto VisitorNotes = VisitorsDiagnostics.find(NextNode);
     NextNode = NextNode->getFirstPred();
     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 PathDiagnosticPieceRef &Note : VisitorNotes->second) {
       llvm::FoldingSetNodeID ID;
       Note->Profile(ID);
-      auto P = DeduplicationSet.insert(ID);
-      if (!P.second)
+      if (!DeduplicationSet.insert(ID).second)
         continue;
 
       if (AddPathEdges)
         addEdgeToPath(PD->getActivePath(), PrevLoc, Note->getLocation());
       updateStackPiecesWithMessage(*Note, CallStack);
       PD->getActivePath().push_front(Note);
     }
   }

 }
 
 void BugReport::markInteresting(const LocationContext *LC) {
   if (!LC)
     return;
   InterestingLocationContexts.insert(LC);
 }
 
-bool BugReport::isInteresting(SVal V) {
+bool BugReport::isInteresting(SVal V)  const {
   return isInteresting(V.getAsRegion()) || isInteresting(V.getAsSymbol());
 }
 
-bool BugReport::isInteresting(SymbolRef sym) {
+bool BugReport::isInteresting(SymbolRef sym)  const {
   if (!sym)
     return false;
   // We don't currently consider metadata symbols to be interesting
   // even if we know their region is interesting. Is that correct behavior?
   return InterestingSymbols.count(sym);
 }
 
-bool BugReport::isInteresting(const MemRegion *R) {
+bool BugReport::isInteresting(const MemRegion *R)  const {
   if (!R)
     return false;
   R = R->getBaseRegion();
   bool b = InterestingRegions.count(R);
   if (b)
     return true;
   if (const auto *SR = dyn_cast<SymbolicRegion>(R))
     return InterestingSymbols.count(SR->getSymbol());
   return false;
 }
 
-bool BugReport::isInteresting(const LocationContext *LC) {
+bool BugReport::isInteresting(const LocationContext *LC)  const {
   if (!LC)
     return false;
   return InterestingLocationContexts.count(LC);
 }
 
 const Stmt *BugReport::getStmt() const {
   if (!ErrorNode)
     return nullptr;
PathDiagnosticLocation BugReport::getLocation(const SourceManager &SM) const {
   assert(Location.isValid());
   return Location;
 }
 
 //===----------------------------------------------------------------------===//
 // Methods for BugReporter and subclasses.
 //===----------------------------------------------------------------------===//
 
-ExplodedGraph &GRBugReporter::getGraph() { return Eng.getGraph(); }
+const ExplodedGraph &GRBugReporter::getGraph() const { return Eng.getGraph(); }
 
 ProgramStateManager&
 GRBugReporter::getStateManager() { return Eng.getStateManager(); }
 
+ProgramStateManager&
+GRBugReporter::getStateManager() const { return Eng.getStateManager(); }
+
 BugReporter::~BugReporter() {
   FlushReports();
 
   // Free the bug reports we are tracking.
   for (const auto I : EQClassesVector)
     delete I;
 }
 
for (auto &P : *Diagnostics) {
     updateExecutedLinesWithDiagnosticPieces(*PD);
     Consumer->HandlePathDiagnostic(std::move(PD));
   }
 }
 
 /// Insert all lines participating in the function signature \p Signature
 /// into \p ExecutedLines.
 static void populateExecutedLinesWithFunctionSignature(
-    const Decl *Signature, SourceManager &SM,
+    const Decl *Signature, const SourceManager &SM,
     FilesToLineNumsMap &ExecutedLines) {
   SourceRange SignatureSourceRange;
   const Stmt* Body = Signature->getBody();
   if (const auto FD = dyn_cast<FunctionDecl>(Signature)) {
     SignatureSourceRange = FD->getSourceRange();
   } else if (const auto OD = dyn_cast<ObjCMethodDecl>(Signature)) {
     SignatureSourceRange = OD->getSourceRange();
   } else {
     return;
   }
   SourceLocation Start = SignatureSourceRange.getBegin();
   SourceLocation End = Body ? Body->getSourceRange().getBegin()
     : SignatureSourceRange.getEnd();
   if (!Start.isValid() || !End.isValid())
     return;
   unsigned StartLine = SM.getExpansionLineNumber(Start);
   unsigned EndLine = SM.getExpansionLineNumber(End);
 
   FileID FID = SM.getFileID(SM.getExpansionLoc(Start));
   for (unsigned Line = StartLine; Line <= EndLine; Line++)
     ExecutedLines[FID].insert(Line);
 }
 
 static void populateExecutedLinesWithStmt(
-    const Stmt *S, SourceManager &SM,
+    const Stmt *S, const SourceManager &SM,
     FilesToLineNumsMap &ExecutedLines) {
   SourceLocation Loc = S->getSourceRange().getBegin();
   if (!Loc.isValid())
     return;
   SourceLocation ExpansionLoc = SM.getExpansionLoc(Loc);
   FileID FID = SM.getFileID(ExpansionLoc);
   unsigned LineNo = SM.getExpansionLineNumber(ExpansionLoc);
   ExecutedLines[FID].insert(LineNo);
 }
 
 /// \return all executed lines including function signatures on the path
 /// starting from \p N.
 static std::unique_ptr<FilesToLineNumsMap>
-findExecutedLines(SourceManager &SM, const ExplodedNode *N) {
+findExecutedLines(const SourceManager &SM, const ExplodedNode *N) {
   auto ExecutedLines = llvm::make_unique<FilesToLineNumsMap>();
 
   while (N) {
     if (N->getFirstPred() == nullptr) {
       // First node: show signature of the entrance point.
       const Decl *D = N->getLocationContext()->getDecl();
       populateExecutedLinesWithFunctionSignature(D, SM, *ExecutedLines);
     } else if (auto CE = N->getLocationAs<CallEnter>()) {
BugReporter::generateDiagnosticForConsumerMap(
 
   if (Out->empty())
     return Out;
 
   MaxValidBugClassSize.updateMax(bugReports.size());
 
   // Examine the report and see if the last piece is in a header. Reset the
   // report location to the last piece in the main source file.
-  AnalyzerOptions &Opts = getAnalyzerOptions();
+  const AnalyzerOptions &Opts = getAnalyzerOptions();
   for (auto const &P : *Out)
     if (Opts.ShouldReportIssuesInMainSourceFile && !Opts.AnalyzeAll)
       P.second->resetDiagnosticLocationToMainFile();
 
   return Out;
 }
 
 void BugReporter::EmitBasicReport(const Decl *DeclWithIssue,

cfe/trunk/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

bool ConditionBRVisitor::patternMatch(const Expr *Ex,
   if (isa<GNUNullExpr>(Ex) || isa<ObjCBoolLiteralExpr>(Ex) ||
       isa<CXXBoolLiteralExpr>(Ex) || isa<IntegerLiteral>(Ex) ||
       isa<FloatingLiteral>(Ex)) {
     // Use heuristics to determine if the expression is a macro
     // expanding to a literal and if so, use the macro's name.
     SourceLocation BeginLoc = OriginalExpr->getBeginLoc();
     SourceLocation EndLoc = OriginalExpr->getEndLoc();
     if (BeginLoc.isMacroID() && EndLoc.isMacroID()) {
-      SourceManager &SM = BRC.getSourceManager();
+      const SourceManager &SM = BRC.getSourceManager();
       const LangOptions &LO = BRC.getASTContext().getLangOpts();
       if (Lexer::isAtStartOfMacroExpansion(BeginLoc, SM, LO) &&
           Lexer::isAtEndOfMacroExpansion(EndLoc, SM, LO)) {
         CharSourceRange R = Lexer::getAsCharRange({BeginLoc, EndLoc}, SM, LO);
         Out << Lexer::getSourceText(R, SM, LO);
         return false;
       }
     }

 //===----------------------------------------------------------------------===//
 // Implementation of LikelyFalsePositiveSuppressionBRVisitor.
 //===----------------------------------------------------------------------===//
 
 void LikelyFalsePositiveSuppressionBRVisitor::finalizeVisitor(
     BugReporterContext &BRC, const ExplodedNode *N, BugReport &BR) {
   // Here we suppress false positives coming from system headers. This list is
   // based on known issues.
-  AnalyzerOptions &Options = BRC.getAnalyzerOptions();
+  const AnalyzerOptions &Options = BRC.getAnalyzerOptions();
   const Decl *D = N->getLocationContext()->getDecl();
 
   if (AnalysisDeclContext::isInStdNamespace(D)) {
     // Skip reports within the 'std' namespace. Although these can sometimes be
     // the user's fault, we currently don't report them very well, and
     // Note that this will not help for any other data structure libraries, like
     // TR1, Boost, or llvm/ADT.
     if (Options.ShouldSuppressFromCXXStandardLibrary) {
if (Options.ShouldSuppressFromCXXStandardLibrary) {
           return;
         }
       }
     }
   }
 
   // Skip reports within the sys/queue.h macros as we do not have the ability to
   // reason about data structure shapes.
-  SourceManager &SM = BRC.getSourceManager();
+  const SourceManager &SM = BRC.getSourceManager();
   FullSourceLoc Loc = BR.getLocation(SM).asLocation();
   while (Loc.isMacroID()) {
     Loc = Loc.getSpellingLoc();
     if (SM.getFilename(Loc).endswith("sys/queue.h")) {
       BR.markInvalid(getTag(), nullptr);
       return;
     }
   }

cfe/trunk/lib/StaticAnalyzer/Core/CallEvent.cpp

if (const auto *BO = dyn_cast<BinaryOperator>(Syntactic))
     Syntactic = BO->getLHS();
 
   return Syntactic;
 }
 
 ObjCMessageKind ObjCMethodCall::getMessageKind() const {
   if (!Data) {
     // Find the parent, ignoring implicit casts.
-    ParentMap &PM = getLocationContext()->getParentMap();
+    const ParentMap &PM = getLocationContext()->getParentMap();
     const Stmt *S = PM.getParentIgnoreParenCasts(getOriginExpr());
 
     // Check if parent is a PseudoObjectExpr.
     if (const auto *POE = dyn_cast_or_null<PseudoObjectExpr>(S)) {
       const Expr *Syntactic = getSyntacticFromForPseudoObjectExpr(POE);
 
       ObjCMessageKind K;
       switch (Syntactic->getStmtClass()) {

cfe/trunk/lib/StaticAnalyzer/Core/ExplodedGraph.cpp

bool ExplodedGraph::shouldCollect(const ExplodedNode *node) {
   // used extensively for generating path diagnostics.
   if (isInterestingLValueExpr(Ex))
     return false;
 
   // Condition 9.
   // Do not collect nodes for non-consumed Stmt or Expr to ensure precise
   // diagnostic generation; specifically, so that we could anchor arrows
   // pointing to the beginning of statements (as written in code).
-  ParentMap &PM = progPoint.getLocationContext()->getParentMap();
+  const ParentMap &PM = progPoint.getLocationContext()->getParentMap();
   if (!PM.isConsumedExpr(Ex))
     return false;
 
   // Condition 10.
   const ProgramPoint SuccLoc = succ->getLocation();
   if (Optional<StmtPoint> SP = SuccLoc.getAs<StmtPoint>())
     if (CallEvent::isCallStmt(SP->getStmt()))
       return false;