[clang][dataflow] Use diagnosis API in optional checker

[samestep]

Summary

Followup to D127898. This patch updates bugprone-unchecked-optional-access to use the new diagnoseCFG function instead of just looking at the exit block.

A followup to this will update the optional model itself to use a noop lattice rather than redundantly computing the diagnostics in both phases of the analysis.

[samestep]

Remove unnecessary ExitBlock code

[sgatev]

clang-tools-extra/clang-tidy/bugprone/UncheckedOptionalAccessCheck.cpp

58

I think the typed API should still be preferred unless we make a call to drop it. The type-erased API is only used internally in the dataflow analysis framework. I suggest taking a DataflowAnalysisState<Lattice> in diagnoseCFG instead of TypeErasedDataflowAnalysisState for now. Would that work?

[samestep]

clang-tools-extra/clang-tidy/bugprone/UncheckedOptionalAccessCheck.cpp

58

That wouldn't be easy to do, because checkDataflow in TestingSupport.h uses the type-erased API. But if you know how to change that to use the non-type-erased API, then we could probably change the signature of diagnoseCFG. I don't know how to do that, though.

[samestep]

• Merge branch 'diagnose-api' into optional-check-diagnose

[samestep]

• Merge branch 'diagnose-api' into optional-check-diagnose

[samestep]

• Merge branch 'diagnose-api' into optional-check-diagnose

[samestep]

• Merge branch 'diagnose-api' into optional-check-diagnose
• Use the updated API

[ymandel]

Nice!

[gribozavr2]

clang-tools-extra/clang-tidy/bugprone/UncheckedOptionalAccessCheck.cpp

66

Please use the range-based llvm;:move() from llvm-project/llvm/include/llvm/ADT/STLExtras.h.

[sgatev]

clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h

126–129 ↗

(On Diff #440702)

[samestep]

clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h

126–129 ↗

(On Diff #440702)

I tried this but it doesn't seem to work; I get this error:

llvm-project/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h:130:13: error: non-const lvalue reference to type 'clang::dataflow::SourceLocationsLattice' cannot bind to a temporary of type 'clang::dataflow::SourceLocationsLattice'
      auto &Lattice =

[samestep]

• Merge branch 'diagnose-api' into optional-check-diagnose
• Update using review comments

clang-tools-extra/clang-tidy/bugprone/UncheckedOptionalAccessCheck.cpp

 #include "clang/AST/DeclTemplate.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Analysis/CFG.h"
 #include "clang/Analysis/FlowSensitive/ControlFlowContext.h"
 #include "clang/Analysis/FlowSensitive/DataflowAnalysisContext.h"
 #include "clang/Analysis/FlowSensitive/DataflowEnvironment.h"
 #include "clang/Analysis/FlowSensitive/DataflowLattice.h"
+#include "clang/Analysis/FlowSensitive/Diagnosis.h"
 #include "clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h"
-#include "clang/Analysis/FlowSensitive/SourceLocationsLattice.h"
 #include "clang/Analysis/FlowSensitive/WatchedLiteralsSolver.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/Any.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/Error.h"
 #include <memory>
 #include <vector>
 
 namespace clang {
 namespace tidy {
 namespace bugprone {
 using ast_matchers::MatchFinder;
-using dataflow::SourceLocationsLattice;
+using dataflow::UncheckedOptionalAccessDiagnosis;
 using dataflow::UncheckedOptionalAccessModel;
 using llvm::Optional;
 
 static constexpr llvm::StringLiteral FuncID("fun");
 
-static Optional<SourceLocationsLattice>
+static Optional<llvm::DenseSet<SourceLocation>>
 analyzeFunction(const FunctionDecl &FuncDecl, ASTContext &ASTCtx) {
   using dataflow::ControlFlowContext;
-  using dataflow::DataflowAnalysisState;
+  using dataflow::TypeErasedDataflowAnalysisState;
   using llvm::Expected;
 
   Expected<ControlFlowContext> Context =
       ControlFlowContext::build(&FuncDecl, FuncDecl.getBody(), &ASTCtx);
   if (!Context)
     return llvm::None;
 
   dataflow::DataflowAnalysisContext AnalysisContext(
       std::make_unique<dataflow::WatchedLiteralsSolver>());
   dataflow::Environment Env(AnalysisContext, FuncDecl);
   UncheckedOptionalAccessModel Analysis(ASTCtx);
-  Expected<std::vector<Optional<DataflowAnalysisState<SourceLocationsLattice>>>>
+  Expected<std::vector<Optional<TypeErasedDataflowAnalysisState>>>
       BlockToOutputState =
-          dataflow::runDataflowAnalysis(*Context, Analysis, Env);
+          dataflow::runTypeErasedDataflowAnalysis(*Context, Analysis, Env);
   if (!BlockToOutputState)
     return llvm::None;
-  assert(Context->getCFG().getExit().getBlockID() < BlockToOutputState->size());
 
-  const Optional<DataflowAnalysisState<SourceLocationsLattice>>
-      &ExitBlockState =
-          (*BlockToOutputState)[Context->getCFG().getExit().getBlockID()];
+  const Optional<TypeErasedDataflowAnalysisState> &ExitBlockState =
   // `runDataflowAnalysis` doesn't guarantee that the exit block is visited;
   // for example, when it is unreachable.
   // FIXME: Diagnose violations even when the exit block is unreachable.
   if (!ExitBlockState)
     return llvm::None;
 
-  return std::move(ExitBlockState->Lattice);
+  UncheckedOptionalAccessDiagnosis Diagnosis(ASTCtx);
+  dataflow::Diagnosis<UncheckedOptionalAccessModel::Lattice,
+                      llvm::DenseSet<SourceLocation>>
+      Diagnose = [&Diagnosis](const Stmt *Stmt,
+                              const UncheckedOptionalAccessModel::Lattice &,
+                              const dataflow::Environment &Env) {
+        return Diagnosis.diagnose(Stmt, Env);
+      };
+
+  return dataflow::diagnoseCFG(*Context, *BlockToOutputState, Env, Analysis,
+                               std::move(Diagnose));
 }
 
 void UncheckedOptionalAccessCheck::registerMatchers(MatchFinder *Finder) {
   using namespace ast_matchers;
 
   auto HasOptionalCallDescendant = hasDescendant(callExpr(callee(cxxMethodDecl(
       ofClass(UncheckedOptionalAccessModel::optionalClassDecl())))));
   Finder->addMatcher(
void UncheckedOptionalAccessCheck::check(
     const MatchFinder::MatchResult &Result) {
   if (Result.SourceManager->getDiagnostics().hasUncompilableErrorOccurred())
     return;
 
   const auto *FuncDecl = Result.Nodes.getNodeAs<FunctionDecl>(FuncID);
   if (FuncDecl->isTemplated())
     return;
 
-  if (Optional<SourceLocationsLattice> Errors =
+  if (Optional<llvm::DenseSet<SourceLocation>> Errors =
           analyzeFunction(*FuncDecl, *Result.Context))
-    for (const SourceLocation &Loc : Errors->getSourceLocations())
+    for (const SourceLocation &Loc : *Errors)
       diag(Loc, "unchecked access to optional value");
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang