[clang][dataflow] In `ControlFlowContext`, handle `Decl` by reference instead of pointer.

[mboehme]

Summary

build() guarantees that we'll always have a Decl, so we can simplify the code.

clang/include/clang/Analysis/FlowSensitive/ControlFlowContext.h

public:
   /// Builds a ControlFlowContext from an AST node. `D` is the function in which
   /// `S` resides. `D` must not be null and `D->isTemplated()` must be false.
   LLVM_DEPRECATED("Use the version that takes a const Decl & instead", "")
   static llvm::Expected<ControlFlowContext> build(const Decl *D, Stmt &S,
                                                   ASTContext &C);
 
   /// Returns the `Decl` containing the statement used to construct the CFG, if
   /// available.
-  const Decl *getDecl() const { return ContainingDecl; }
+  const Decl &getDecl() const { return ContainingDecl; }
 
   /// Returns the CFG that is stored in this context.
   const CFG &getCFG() const { return *Cfg; }
 
   /// Returns a mapping from statements to basic blocks that contain them.
   const llvm::DenseMap<const Stmt *, const CFGBlock *> &getStmtToBlock() const {
     return StmtToBlock;
   }
 
   /// Returns whether `B` is reachable from the entry block.
   bool isBlockReachable(const CFGBlock &B) const {
     return BlockReachable[B.getBlockID()];
   }
 
 private:
-  // FIXME: Once the deprecated `build` method is removed, mark `D` as "must not
-  // be null" and add an assertion.
-  ControlFlowContext(const Decl *D, std::unique_ptr<CFG> Cfg,
+  ControlFlowContext(const Decl &D, std::unique_ptr<CFG> Cfg,
                      llvm::DenseMap<const Stmt *, const CFGBlock *> StmtToBlock,
                      llvm::BitVector BlockReachable)
       : ContainingDecl(D), Cfg(std::move(Cfg)),
         StmtToBlock(std::move(StmtToBlock)),
         BlockReachable(std::move(BlockReachable)) {}
 
   /// The `Decl` containing the statement used to construct the CFG.
-  const Decl *ContainingDecl;
+  const Decl &ContainingDecl;
   std::unique_ptr<CFG> Cfg;
   llvm::DenseMap<const Stmt *, const CFGBlock *> StmtToBlock;
   llvm::BitVector BlockReachable;
 };
 
 } // namespace dataflow
 } // namespace clang
 
 #endif // LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_CONTROLFLOWCONTEXT_H

clang/lib/Analysis/FlowSensitive/ControlFlowContext.cpp

return llvm::createStringError(
         std::make_error_code(std::errc::invalid_argument),
         "CFG::buildCFG failed");
 
   llvm::DenseMap<const Stmt *, const CFGBlock *> StmtToBlock =
       buildStmtToBasicBlockMap(*Cfg);
 
   llvm::BitVector BlockReachable = findReachableBlocks(*Cfg);
 
-  return ControlFlowContext(&D, std::move(Cfg), std::move(StmtToBlock),
+  return ControlFlowContext(D, std::move(Cfg), std::move(StmtToBlock),
                             std::move(BlockReachable));
 }
 
 llvm::Expected<ControlFlowContext>
 ControlFlowContext::build(const Decl *D, Stmt &S, ASTContext &C) {
   if (D == nullptr)
     return llvm::createStringError(
         std::make_error_code(std::errc::invalid_argument),
         "Declaration must not be null");
 
   return build(*D, S, C);
 }
 
 } // namespace dataflow
 } // namespace clang

clang/lib/Analysis/FlowSensitive/HTMLLogger.cpp

 public:
   explicit HTMLLogger(StreamFactory Streams) : Streams(std::move(Streams)) {}
   void beginAnalysis(const ControlFlowContext &CFG,
                      TypeErasedDataflowAnalysis &A) override {
     OS = Streams();
     this->CFG = &CFG;
     *OS << llvm::StringRef(HTMLLogger_html).split("<?INJECT?>").first;
 
-    if (const auto *D = CFG.getDecl()) {
-      const auto &SM = A.getASTContext().getSourceManager();
-      *OS << "<title>";
-      if (const auto *ND = dyn_cast<NamedDecl>(D))
-        *OS << ND->getNameAsString() << " at ";
-      *OS << SM.getFilename(D->getLocation()) << ":"
-          << SM.getSpellingLineNumber(D->getLocation());
-      *OS << "</title>\n";
-    };
+    const auto &D = CFG.getDecl();
+    if (const auto *ND = dyn_cast<NamedDecl>(&D))
+    *OS << SM.getFilename(D.getLocation()) << ":"
+        << SM.getSpellingLineNumber(D.getLocation());
 
     *OS << "<style>" << HTMLLogger_css << "</style>\n";
     *OS << "<script>" << HTMLLogger_js << "</script>\n";
 
     writeCode();
     writeCFG();
 
     *OS << "<script>var HTMLLoggerData = \n";
void writeBlock(const CFGBlock &B, unsigned Iters) {
     });
   }
 
   // Write the code of function being examined.
   // We want to overlay the code with <span>s that mark which BB particular
   // tokens are associated with, and even which BB element (so that clicking
   // can select the right element).
   void writeCode() {
-    if (!CFG->getDecl())
-      return;
-    const auto &AST = CFG->getDecl()->getASTContext();
+    const auto &AST = CFG->getDecl().getASTContext();
     bool Invalid = false;
 
     // Extract the source code from the original file.
     // Pretty-printing from the AST would probably be nicer (no macros or
     // indentation to worry about), but we need the boundaries of particular
     // AST nodes and the printer doesn't provide this.
     auto Range = clang::Lexer::makeFileCharRange(
-        CharSourceRange::getTokenRange(CFG->getDecl()->getSourceRange()),
+        CharSourceRange::getTokenRange(CFG->getDecl().getSourceRange()),
         AST.getSourceManager(), AST.getLangOpts());
     if (Range.isInvalid())
       return;
     llvm::StringRef Code = clang::Lexer::getSourceText(
         Range, AST.getSourceManager(), AST.getLangOpts(), &Invalid);
     if (Invalid)
       return;
 

clang/lib/Analysis/FlowSensitive/Logger.cpp

TextualLogger(llvm::raw_ostream &OS)
       : OS(OS), ShowColors(llvm::WithColor::defaultAutoDetectFunction()(OS)) {}
 
   virtual void beginAnalysis(const ControlFlowContext &CFG,
                              TypeErasedDataflowAnalysis &Analysis) override {
     {
       llvm::WithColor Header(OS, llvm::raw_ostream::Colors::RED, /*Bold=*/true);
       OS << "=== Beginning data flow analysis ===\n";
     }
-    if (auto *D = CFG.getDecl()) {
-      D->print(OS);
-      OS << "\n";
-      D->dump(OS);
-    }
+    auto &D = CFG.getDecl();
+    D.print(OS);
+    D.dump(OS);
     CurrentCFG = &CFG.getCFG();
     CurrentCFG->print(OS, Analysis.getASTContext().getLangOpts(), ShowColors);
     CurrentAnalysis = &Analysis;
   }
   virtual void endAnalysis() override {
     llvm::WithColor Header(OS, llvm::raw_ostream::Colors::RED, /*Bold=*/true);
     unsigned Blocks = 0, Steps = 0;
     for (const auto &E : VisitCount) {

clang/lib/Analysis/FlowSensitive/Transfer.cpp

void transferInlineCall(const E *S, const FunctionDecl *F) {
 
     auto ExitBlock = CFCtx->getCFG().getExit().getBlockID();
 
     auto CalleeEnv = Env.pushCall(S);
 
     // FIXME: Use the same analysis as the caller for the callee. Note,
     // though, that doing so would require support for changing the analysis's
     // ASTContext.
-    assert(CFCtx->getDecl() != nullptr &&
-           "ControlFlowContexts in the environment should always carry a decl");
-    auto Analysis = NoopAnalysis(CFCtx->getDecl()->getASTContext(),
+    auto Analysis = NoopAnalysis(CFCtx->getDecl().getASTContext(),
                                  DataflowAnalysisOptions{Options});
 
     auto BlockToOutputState =
         dataflow::runDataflowAnalysis(*CFCtx, Analysis, CalleeEnv);
     assert(BlockToOutputState);
     assert(ExitBlock < BlockToOutputState->size());
 
     auto &ExitState = (*BlockToOutputState)[ExitBlock];

clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp

 class PrettyStackTraceAnalysis : public llvm::PrettyStackTraceEntry {
 public:
   PrettyStackTraceAnalysis(const ControlFlowContext &CFCtx, const char *Message)
       : CFCtx(CFCtx), Message(Message) {}
 
   void print(raw_ostream &OS) const override {
     OS << Message << "\n";
     OS << "Decl:\n";
-    CFCtx.getDecl()->dump(OS);
+    CFCtx.getDecl().dump(OS);
     OS << "CFG:\n";
     CFCtx.getCFG().print(OS, LangOptions(), false);
   }
 
 private:
   const ControlFlowContext &CFCtx;
   const char *Message;
 };