[clang][dataflow] Add API to separate analysis from diagnosis

[samestep]

Summary

This patch adds an optional PostVisitStmt parameter to the runTypeErasedDataflowAnalysis function, which does one more pass over all statements in the CFG after a fixpoint is reached. It then defines a diagnose method for the optional model in a new UncheckedOptionalAccessDiagnosis class, but only integrates that into the tests and not the actual optional check for clang-tidy. That will be done in a followup patch.

The primary motivation is to separate the implementation of the unchecked optional access check into two parts, to allow for further refactoring of just the model part later, while leaving the checking part alone. Currently there is duplication between the transferUnwrapCall and diagnoseUnwrapCall functions, but that will be dealt with in the followup.

Because diagnostics are now all gathered into one collection rather than being populated at each program point like when computing a fixpoint, this patch removes the usage of Pair and UnorderedElementsAre from the optional model tests, and instead modifies all their expectations to simply check the stringified set of diagnostics against a single string, either "safe" or some concatenation of "unsafe: input.cc:y:x". This is not ideal as it loses any connection to the /*[[check]]*/ annotations in the source strings, but it does still retain the source locations from the diagnostic strings themselves.

[ymandel]

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

35

I'm not sure that this is valid style. It's essentially a unit type, which I quite like, but I've never seen this done before.

64

Please describe this parameter.

103

The virtual function seems out of place here, given that everything else is statically resolved. Either drop virtual or move to the dyn. typed super class.

That said, I'm not clear on why this isn't a free function. I imagine a model of creating the analysis, running it and that results in blocks annotated with Environments and custome lattices. Then, you run any function you want over that using some visitor template helper. To account for state, we either make it an explicit parameter or take a std::function.

clang/include/clang/Analysis/FlowSensitive/MatchSwitch.h

52

this implies that we want to support some form of accumulation. I'd argue that any accumulation should already occur in the lattice (or the environment) and this should be a straight read of the state and some output. So, the TransferState struct should be enough.

[tschuett]

C++ seems to be tied to templates. I wonder if super classes resp. inheritance would make your life easier. You can explicitly define the API and documentation. You could provide default implementations.

[xazax.hun]

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

66

While doing yet another iteration after we reached the fixed point is a valid approach, many analyses have a monotonic property when it comes to emitting diagnostics. In this case, when the analysis discovered that an optional access is unsafe in one of the iterations I would not expect it to become safe in subsequent iterations. In most of the cases this makes collecting diagnostics eagerly a viable option and saves us from doing one more traversal of the CFG. On the other hand, we need to be careful to not to emit duplicate diagnostics.

I wonder whether, from a user point of view, not having to do one more iteration is a more ergonomic interface.

[samestep]

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

66

@xazax.hun Agreed, I don't think for this particular analysis there's a risk of diagnostics being prematurely added and then becoming invalid as the analysis progresses. However, the broader goal of this patch is to separate the information-gathering part of the analysis to the diagnostic-flagging part of the analysis, with the hope that we can maybe derive the former automatically while still allowing the latter to be written manually. It seems to me that it would be infeasible to automatically derive both.

[samestep]

Only add the new API, don't change the check

[sgatev]

clang/include/clang/Analysis/FlowSensitive/Diagnosis.h

26 ↗

(On Diff #438891)

Let's add some documentation for Diagnosis and diagnoseCFG.

27 ↗

(On Diff #438891)

#include <functional>

32 ↗

(On Diff #438891)

#include <vector> and #include "llvm/ADT/Optional.h"

49 ↗

(On Diff #438891)

#include <utility>

clang/include/clang/Analysis/FlowSensitive/MatchSwitch.h

49

Move this to Diagnosis.h?

clang/include/clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h

83

Move this to a new UncheckedOptionalAccessDiagnosis.(h,cpp)?

[samestep]

Comment Diagnosis.h and add missing headers

[samestep]

clang/include/clang/Analysis/FlowSensitive/MatchSwitch.h

49

I'd prefer to keep it in MatchSwitch.h alongside TransferState, unless we plan to, e.g., move that type to DataflowAnalysis.h.

clang/include/clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h

83

OK! I'll do that next.

[samestep]

Try to fix the broken patch

[samestep]

clang/include/clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h

83

Actually, @sgatev would that go under FlowSensitive/Models/ or just under FlowSensitive/?

[sgatev]

clang/include/clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h

83

I suggest keeping it under FlowSensitive/Models/ for now. We can change that at a later point if there's a better alternative.

[samestep]

clang/include/clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h

83

Where should I put the UncheckedOptionalAccessModelOptions type and ignorableOptional function that need to be shared between both the model and the diagnosis?

[samestep]

clang/include/clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h

83

Same question for the following other helper functions:

• hasOptionalType
• isOptionalMemberCallWithName
• isOptionalOperatorCallWithName

Given how much code is shared between the two, I'm really not sure whether it's the best idea to move this into a separate file in this patch...

[xazax.hun]

clang/lib/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.cpp

535

I think this should be moved closer to its use.

675–676

This logic is duplicated between the check and the diagnosis. I think it would be nice to factor this out to avoid these two parts getting out of sync.

[samestep]

• Merge branch 'main' into diagnose-api
• Incorporate Gábor's suggestions

[sgatev]

clang/include/clang/Analysis/FlowSensitive/Diagnosis.h

57 ↗

(On Diff #439372)

Better to remove this and rely on NRVO? https://en.cppreference.com/w/cpp/language/copy_elision

clang/include/clang/Analysis/FlowSensitive/MatchSwitch.h

49

Fair enough, but generally I see TransferState and DiagnoseState as very specific to the dataflow analysis framework whereas MatchSwitchBuilder seems to be a bit more generic so I'd consider separating them.

clang/include/clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h

83

I suggest either declaring those in the header and using them from UncheckedOptionalAccessDiagnosis.cpp or moving them to a separate file and including them both in the model and in the diagnosis. In general I think it's fair if the diagnosis depends on the model, but not the other way around. It's perfectly fine if we do this refactoring in a follow up.

[samestep]

clang/include/clang/Analysis/FlowSensitive/Diagnosis.h

57 ↗

(On Diff #439372)

Ah OK, I'm not a C++ expert so I wasn't sure when to write std::move and when not to. Will do, thanks!

clang/include/clang/Analysis/FlowSensitive/MatchSwitch.h

49

Sure, if people think it makes sense to put those two types elsewhere then we can do that in a followup.

clang/include/clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h

83

Yep, makes sense; I just didn't want to make declarations for all those in a header file in this patch.

[samestep]

• Remove unnecessary std::move

[gribozavr2]

clang/include/clang/Analysis/FlowSensitive/Diagnosis.h

38 ↗

(On Diff #439372)

This function seems pretty general and not necessarily tied to diagnostics.

WDYT about using "visitor" in the name?

For example, "visitDataflowAnalysisResults".

The "Diagnosis" would also become "DataflowAnalysisResultVisitor".

42 ↗

(On Diff #439372)

I'm leaning towards std::vector<Diag> instead of a set, to avoid requiring that Diag is hashable. Users who need hash-based deduplication can easily do it themselves (but why would they have duplication? we only visit each Stmt once)

57 ↗

(On Diff #439372)

https://stackoverflow.com/questions/14856344/when-should-stdmove-be-used-on-a-function-return-value

clang/include/clang/Analysis/FlowSensitive/MatchSwitch.h

49

For now, since there is only a single user, I'd actually prefer to move it into UncheckedOptionalAccessDiagnosis itself. It is a trivial component, basically a std::pair, it seems that exposing it as a public API might not be that helpful.

clang/include/clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h

85

"Diagnosis" sounds like the result. Should this be a "Diagnoser"?

clang/unittests/Analysis/FlowSensitive/TestingSupport.h

76

It is better to name a function with a verb. WDYT about "VerifyResults"?

If you agree, please also update the functions below.

162

204

Can we use diagnoseCFG to implement the loop above?

clang/unittests/Analysis/FlowSensitive/UncheckedOptionalAccessModelTest.cpp

1914

The original was unsafe, is it an intentional change?

[xazax.hun]

clang/include/clang/Analysis/FlowSensitive/Diagnosis.h

38–42 ↗

(On Diff #439411)

I feel a bit uneasy about this API. The need of helpers in the tests is a signal that this API might not be ergonomic as is. One needs to pass a lot of stuff in, and it is really error prone. For example, the user might get confused what Environment to pass in. Or one might pass the wrong Analysis if there are multiple similar ones in scope. I wonder if there is a way to reduce the ceremony needed to get diagnostics out. How about adding an optional argument to runDataflowAnalysis function to collect the results? I wonder if that would be a bit cleaner. You do not need to change the return type of that function, the collector object could take a reference to the llvm::DenseSet<Diag> that it populates.

clang/include/clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h

92

Do we expect this to modify the ASTContext? Could this be a const ref instead?

[xazax.hun]

clang/include/clang/Analysis/FlowSensitive/Diagnosis.h

38–42 ↗

(On Diff #439411)

Moreover, if we pass the diagnostic function to runDataflowAnalysis, the fact whether we collect diagnostic during the fixed-point iteration or after that in a separate pass becomes an implementation detail. We can easily change back and forth without affecting the callers. The current API mandates an implementation approach and makes it harder to change in the future.

[samestep]

clang/include/clang/Analysis/FlowSensitive/Diagnosis.h

38 ↗

(On Diff #439372)

Sure, that sounds fine to me. What do you think about @xazax.hun's suggested alternate API? If we go with that, would we rename it to say "visitor" regardless?

42 ↗

(On Diff #439372)

This makes a lot of sense, I'll make that change. Somehow along the way I forgot that the whole reason we even needed a set was because we were using it as a lattice when computing a fixpoint, but you're right that since we're pulling this out of the fixpoint iteration, we a vector would do fine.

57 ↗

(On Diff #439372)

Thanks!

38–42 ↗

(On Diff #439411)

I think this makes a lot of sense. I agree that the current set of parameters is unwieldy. I hadn't thought about your point of hiding the separate pass as an implementation detail, but that also makes sense to me. @gribozavr2 @ymandel @sgatev thoughts?

clang/include/clang/Analysis/FlowSensitive/MatchSwitch.h

49

That's also fine; I can make that change here.

clang/include/clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h

85

Sure, I can change it to say "Diagnoser" instead (unless we want to just replace it with "Visitor").

92

I'd guess it shouldn't; I was mostly just copying the ASTContext & field from the DataflowAnalysis class, which is not const. I can try changing it to const here, though.

clang/unittests/Analysis/FlowSensitive/TestingSupport.h

76

Sounds good to me, I can do that.

204

Possibly! I'll look into it.

clang/unittests/Analysis/FlowSensitive/UncheckedOptionalAccessModelTest.cpp

1914

Oh! Good catch, I didn't notice that. Will fix.

[gribozavr2]

clang/include/clang/Analysis/FlowSensitive/Diagnosis.h

38–42 ↗

(On Diff #439411)

I think that's a good idea, it will make a simpler API for typical usage scenarios. I still think there might be space for an API like diagnoseCFG (e.g., if you want to run multiple visitations of the analysis results), but we don't have a use case for it so far.

[samestep]

clang/include/clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h

92

@xazax.hun Coming back to this today, I remembered why it has to be ASTContext & and not const ASTContext &: because MatchSwitch requires it to not be const.

[xazax.hun]

clang/include/clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h

92

Thanks! Do you mean MatchSwitch cannot be refactored to use const ASTContext&? I quickly skimmed through the code and it looks like almost every instance of ASTContext is non-const. So I think it is ok to leave as is for this PR. I am also not sure if making it const at more places would bring any significant value.

[samestep]

• Merge branch 'main' into diagnose-api
• WIP

[samestep]

• Merge branch 'main' into diagnose-api

[samestep]

• Bring back Diagnosis.h

[samestep]

• Implement Gábor's suggestion
• Merge branch 'main' into diagnose-api

[ymandel]

clang/include/clang/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.h

126 ↗

(On Diff #440687)

Please update comment to mention this new param (and that its optional)

clang/unittests/Analysis/FlowSensitive/TestingSupport.h

66

nit: since this includes both inputs and results, maybe AnalysisData?

111

nit: i prefer explicit comparisons, so MakePostVisitStmt != nullptr.

176

187–206

any chance that this could be folded into MakePostVisitStmt?

clang/unittests/Analysis/FlowSensitive/UncheckedOptionalAccessModelTest.cpp

1254

[xazax.hun]

Thanks, LGTM!

[gribozavr2]

clang/include/clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h

85

Not done?

clang/unittests/Analysis/FlowSensitive/TestingSupport.h

159–160

170

clang/unittests/Analysis/FlowSensitive/UncheckedOptionalAccessModelTest.cpp

2475–2476

[sgatev]

clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp

401 ↗

(On Diff #440687)

Let's harmonize the arguments to transferBlock and runTypeErasedDataflowAnalysis. I think in both cases we only need access to the internal Stmt so there's no need to pass CFGStmt to transferBlock. This way we can pass PostVisitStmt directly here without having to wrap it in a lambda.

clang/unittests/Analysis/FlowSensitive/TestingSupport.h

76–77

Why is this a function that returns a function? Couldn't it be simply a void function, like VerifyResults?

[samestep]

Fixed all the minor nits and responded to some comments.

clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp

401 ↗

(On Diff #440687)

Makes sense to me; should I do that in a followup?

clang/unittests/Analysis/FlowSensitive/TestingSupport.h

76–77

It needs to take in the ASTContext, and it needs to be able to close over state; see the one we pass from UncheckedOptionalAccessModelTest.cpp.

187–206

Looking into this now.

clang/unittests/Analysis/FlowSensitive/UncheckedOptionalAccessModelTest.cpp

2475–2476

I don't think this is correct, is it?

[samestep]

• Merge branch 'main' into diagnose-api
• Fix minor nits

[samestep]

• Tidy AnalysisData struct and PostVisitStmt param

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

 #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/Models/UncheckedOptionalAccessModel.h"
-#include "clang/Analysis/FlowSensitive/SourceLocationsLattice.h"
+#include "clang/Analysis/FlowSensitive/NoopLattice.h"
+#include "clang/Analysis/FlowSensitive/SourceLocations.h"
 #include "clang/Analysis/FlowSensitive/WatchedLiteralsSolver.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/Any.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::NoopLattice;
+using dataflow::SourceLocations;
+using dataflow::TypeErasedDataflowAnalysisState;
 using dataflow::UncheckedOptionalAccessModel;
 using llvm::Optional;
 
 static constexpr llvm::StringLiteral FuncID("fun");
 
-static Optional<SourceLocationsLattice>
-analyzeFunction(const FunctionDecl &FuncDecl, ASTContext &ASTCtx) {
+static Optional<SourceLocations> analyzeFunction(const FunctionDecl &FuncDecl,
+                                                 ASTContext &ASTCtx) {
   using dataflow::ControlFlowContext;
   using dataflow::DataflowAnalysisState;
   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());
+  auto &BlockStates = *BlockToOutputState;
 
-  const Optional<DataflowAnalysisState<SourceLocationsLattice>>
-      &ExitBlockState =
-          (*BlockToOutputState)[Context->getCFG().getExit().getBlockID()];
-  // `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.hasValue())
-    return llvm::None;
+  SourceLocations Locs;
+  for (const CFGBlock *Block : Context->getCFG()) {
+    // Skip blocks that were not evaluated.
+    if (!BlockStates[Block->getBlockID()].hasValue())
+      continue;
+
+    transferBlock(
+        *Context, BlockStates, *Block, Env, Analysis,
+        [&Locs, &Analysis](const clang::CFGStmt &Stmt,
+                           const TypeErasedDataflowAnalysisState &State) {
+          auto *Lattice = llvm::any_cast<NoopLattice>(&State.Lattice.Value);
+          Analysis.check(Stmt.getStmt(), Locs, *Lattice, State.Env);
+        });
+  }
 
-  return std::move(ExitBlockState->Lattice);
+  return std::move(Locs);
 }
 
 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<SourceLocations> 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

clang/docs/tools/clang-formatted-files.txt

 clang/include/clang/Analysis/FlowSensitive/ControlFlowContext.h
 clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h
 clang/include/clang/Analysis/FlowSensitive/DataflowAnalysisContext.h
 clang/include/clang/Analysis/FlowSensitive/DataflowEnvironment.h
 clang/include/clang/Analysis/FlowSensitive/DataflowLattice.h
 clang/include/clang/Analysis/FlowSensitive/DataflowWorklist.h
 clang/include/clang/Analysis/FlowSensitive/MapLattice.h
 clang/include/clang/Analysis/FlowSensitive/MatchSwitch.h
+clang/include/clang/Analysis/FlowSensitive/NoopLattice.h
 clang/include/clang/Analysis/FlowSensitive/Solver.h
-clang/include/clang/Analysis/FlowSensitive/SourceLocationsLattice.h
+clang/include/clang/Analysis/FlowSensitive/SourceLocations.h
 clang/include/clang/Analysis/FlowSensitive/StorageLocation.h
 clang/include/clang/Analysis/FlowSensitive/Transfer.h
 clang/include/clang/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.h
 clang/include/clang/Analysis/FlowSensitive/Value.h
 clang/include/clang/Analysis/FlowSensitive/WatchedLiteralsSolver.h
 clang/include/clang/APINotes/APINotesYAMLCompiler.h
 clang/include/clang/APINotes/Types.h
 clang/include/clang/AST/AST.h

 clang/include/clang-c/FatalErrorHandler.h
 clang/include/clang-c/Index.h
 clang/lib/Analysis/CalledOnceCheck.cpp
 clang/lib/Analysis/CloneDetection.cpp
 clang/lib/Analysis/CodeInjector.cpp
 clang/lib/Analysis/FlowSensitive/ControlFlowContext.cpp
 clang/lib/Analysis/FlowSensitive/DataflowAnalysisContext.cpp
 clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp
-clang/lib/Analysis/FlowSensitive/SourceLocationsLattice.cpp
+clang/lib/Analysis/FlowSensitive/SourceLocations.cpp
 clang/lib/Analysis/FlowSensitive/Transfer.cpp
 clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp
 clang/lib/Analysis/FlowSensitive/WatchedLiteralsSolver.cpp
 clang/lib/Analysis/plugins/CheckerDependencyHandling/CheckerDependencyHandling.cpp
 clang/lib/Analysis/plugins/SampleAnalyzer/MainCallChecker.cpp
 clang/lib/APINotes/APINotesFormat.h
 clang/lib/APINotes/APINotesTypes.cpp
 clang/lib/APINotes/APINotesYAMLCompiler.cpp

 clang/unittests/Analysis/FlowSensitive/DataflowAnalysisContextTest.cpp
 clang/unittests/Analysis/FlowSensitive/DataflowEnvironmentTest.cpp
 clang/unittests/Analysis/FlowSensitive/MapLatticeTest.cpp
 clang/unittests/Analysis/FlowSensitive/MatchSwitchTest.cpp
 clang/unittests/Analysis/FlowSensitive/MultiVarConstantPropagationTest.cpp
 clang/unittests/Analysis/FlowSensitive/NoopAnalysis.h
 clang/unittests/Analysis/FlowSensitive/SingleVarConstantPropagationTest.cpp
 clang/unittests/Analysis/FlowSensitive/SolverTest.cpp
-clang/unittests/Analysis/FlowSensitive/SourceLocationsLatticeTest.cpp
 clang/unittests/Analysis/FlowSensitive/TestingSupport.cpp
 clang/unittests/Analysis/FlowSensitive/TestingSupport.h
 clang/unittests/Analysis/FlowSensitive/TestingSupportTest.cpp
 clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp
 clang/unittests/AST/ASTImporterFixtures.cpp
 clang/unittests/AST/ASTImporterFixtures.h
 clang/unittests/AST/ASTImporterObjCTest.cpp
 clang/unittests/AST/ASTPrint.h

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

 #include "llvm/ADT/Any.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Error.h"
 
 namespace clang {
 namespace dataflow {
 
+using NoopDiags = std::tuple<>;
+
 /// Base class template for dataflow analyses built on a single lattice type.
 ///
 /// Requirements:
 ///
 ///  `Derived` must be derived from a specialization of this class template and
 ///  must provide the following public members:
 ///   * `LatticeT initialElement()` - returns a lattice element that models the
 ///     initial state of a basic block;
 ///   * `void transfer(const Stmt *, LatticeT &, Environment &)` - applies the
 ///     analysis transfer function for a given statement and lattice element.
 ///
 ///  `Derived` can optionally override the following members:
 ///   * `bool merge(QualType, const Value &, const Value &, Value &,
 ///     Environment &)` -  joins distinct values. This could be a strict
 ///     lattice join or a more general widening operation.
+///   * `void check(const Stmt *, DiagsT &, const LatticeT &, const Environment
+///     &)` - collects diagnostics for a given statement and analysis result.
 ///
 ///  `LatticeT` is a bounded join-semilattice that is used by `Derived` and must
 ///  provide the following public members:
 ///   * `LatticeJoinEffect join(const LatticeT &)` - joins the object and the
 ///     argument by computing their least upper bound, modifies the object if
 ///     necessary, and returns an effect indicating whether any changes were
 ///     made to it;
 ///   * `bool operator==(const LatticeT &) const` - returns true if and only if
 ///     the object is equal to the argument.
-template <typename Derived, typename LatticeT>
+///
+/// `DiagsT` must have a default constructor.
+template <typename Derived, typename LatticeT, typename DiagsT = NoopDiags>
 class DataflowAnalysis : public TypeErasedDataflowAnalysis {
 public:
   /// Bounded join-semilattice that is used in the analysis.
   using Lattice = LatticeT;
+  /// Diagnostics set that is used after the analysis.
+  using Diags = DiagsT;
 
   explicit DataflowAnalysis(ASTContext &Context) : Context(Context) {}
   explicit DataflowAnalysis(ASTContext &Context, bool ApplyBuiltinTransfer)
       : TypeErasedDataflowAnalysis(ApplyBuiltinTransfer), Context(Context) {}
 
   ASTContext &getASTContext() final { return Context; }
 
   TypeErasedLattice typeErasedInitialElement() final {
public:
   }
 
   void transferTypeErased(const Stmt *Stmt, TypeErasedLattice &E,
                           Environment &Env) final {
     Lattice &L = llvm::any_cast<Lattice &>(E.Value);
     static_cast<Derived *>(this)->transfer(Stmt, L, Env);
   }
 
+  virtual void check(const Stmt *Stmt, Diags &E, const Lattice &L,
+                     const Environment &Env) {}
+
 private:
   ASTContext &Context;
 };
 
 // Model of the program at a given program point.
 template <typename LatticeT> struct DataflowAnalysisState {
   // Model of a program property.
   LatticeT Lattice;

clang/include/clang/Analysis/FlowSensitive/MatchSwitch.h

template <typename LatticeT> struct TransferState {
   TransferState(LatticeT &Lattice, Environment &Env)
       : Lattice(Lattice), Env(Env) {}
 
   /// Current lattice element.
   LatticeT &Lattice;
   Environment &Env;
 };
 
+/// A common form of state shared between the cases of a check function.
+template <typename DiagsT> struct CheckState {
+  CheckState(DiagsT &Diags, const Environment &Env) : Diags(Diags), Env(Env) {}
+
+  /// Current set of diagnostics.
+  DiagsT &Diags;
+  const Environment &Env;
+};
+
 /// Matches against `Stmt` and, based on its structure, dispatches to an
 /// appropriate handler.
 template <typename State>
 using MatchSwitch = std::function<void(const Stmt &, ASTContext &, State &)>;
 
 /// Collects cases of a "match switch": a collection of matchers paired with
 /// callbacks, which together define a switch that can be applied to a
 /// `Stmt`. This structure can simplify the definition of `transfer` functions

clang/include/clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h

 #ifndef CLANG_ANALYSIS_FLOWSENSITIVE_MODELS_UNCHECKEDOPTIONALACCESSMODEL_H
 #define CLANG_ANALYSIS_FLOWSENSITIVE_MODELS_UNCHECKEDOPTIONALACCESSMODEL_H
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Stmt.h"
 #include "clang/Analysis/FlowSensitive/DataflowAnalysis.h"
 #include "clang/Analysis/FlowSensitive/DataflowEnvironment.h"
 #include "clang/Analysis/FlowSensitive/MatchSwitch.h"
-#include "clang/Analysis/FlowSensitive/SourceLocationsLattice.h"
+#include "clang/Analysis/FlowSensitive/NoopLattice.h"
+#include "clang/Analysis/FlowSensitive/SourceLocations.h"
+#include "clang/Basic/SourceLocation.h"
+#include <utility>
 
 namespace clang {
 namespace dataflow {
 
 // FIXME: Explore using an allowlist-approach, where constructs supported by the
 // analysis are always enabled and additional constructs are enabled through the
 // `Options`.
 struct UncheckedOptionalAccessModelOptions {
   /// Ignore optionals reachable through overloaded `operator*` or `operator->`
   /// (other than those of the optional type itself). The analysis does not
   /// equate the results of such calls, so it can't identify when their results
   /// are used safely (across calls), resulting in false positives in all such
   /// cases. Note: this option does not cover access through `operator[]`.
   bool IgnoreSmartPointerDereference = false;
 };
 
-/// Dataflow analysis that discovers unsafe accesses of optional values and
-/// adds the respective source locations to the lattice.
+/// Dataflow analysis that models whether optionals hold values or not.
 ///
 /// Models the `std::optional`, `absl::optional`, and `base::Optional` types.
-///
-/// FIXME: Consider separating the models from the unchecked access analysis.
 class UncheckedOptionalAccessModel
-    : public DataflowAnalysis<UncheckedOptionalAccessModel,
-                              SourceLocationsLattice> {
+    : public DataflowAnalysis<UncheckedOptionalAccessModel, NoopLattice,
+                              SourceLocations> {
 public:
   UncheckedOptionalAccessModel(
       ASTContext &AstContext, UncheckedOptionalAccessModelOptions Options = {});
 
   /// Returns a matcher for the optional classes covered by this model.
   static ast_matchers::DeclarationMatcher optionalClassDecl();
 
-  static SourceLocationsLattice initialElement() {
-    return SourceLocationsLattice();
-  }
+  static NoopLattice initialElement() { return {}; }
+
+  void transfer(const Stmt *Stmt, NoopLattice &State, Environment &Env);
 
-  void transfer(const Stmt *Stmt, SourceLocationsLattice &State,
-                Environment &Env);
+  /// Discovers unsafe accesses of optional values and adds the respective
+  /// source locations to a set.
+  void check(const Stmt *Stmt, SourceLocations &Locs, const NoopLattice &,
+             const Environment &Env) override;
 
   bool compareEquivalent(QualType Type, const Value &Val1,
                          const Environment &Env1, const Value &Val2,
                          const Environment &Env2) override;
 
   bool merge(QualType Type, const Value &Val1, const Environment &Env1,
              const Value &Val2, const Environment &Env2, Value &MergedVal,
              Environment &MergedEnv) override;
 
 private:
-  MatchSwitch<TransferState<SourceLocationsLattice>> TransferMatchSwitch;
+  UncheckedOptionalAccessModel(
+      ASTContext &AstContext,
+      std::pair<MatchSwitch<TransferState<NoopLattice>>,
+                MatchSwitch<CheckState<SourceLocations>>>
+          MatchSwitches);
+
+  MatchSwitch<TransferState<NoopLattice>> TransferMatchSwitch;
+  MatchSwitch<CheckState<SourceLocations>> CheckMatchSwitch;
 };
 
 } // namespace dataflow
 } // namespace clang
 
 #endif // CLANG_ANALYSIS_FLOWSENSITIVE_MODELS_UNCHECKEDOPTIONALACCESSMODEL_H

clang/include/clang/Analysis/FlowSensitive/NoopLattice.h

+//===-- NoopLattice.h -------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines the lattice with exactly one element.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_NOOP_LATTICE_H
+#define LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_NOOP_LATTICE_H
+
+#include "clang/Analysis/FlowSensitive/DataflowLattice.h"
+#include <ostream>
+
+namespace clang {
+namespace dataflow {
+
+/// Trivial lattice for dataflow analysis with exactly one element.
+///
+/// Useful for analyses that only need the Environment and nothing more.
+class NoopLattice {
+public:
+  bool operator==(const NoopLattice &Other) const { return true; }
+
+  LatticeJoinEffect join(const NoopLattice &Other) {
+    return LatticeJoinEffect::Unchanged;
+  }
+};
+
+inline std::ostream &operator<<(std::ostream &OS, const NoopLattice &) {
+  return OS << "noop";
+}
+
+} // namespace dataflow
+} // namespace clang
+
+#endif // LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_NOOP_LATTICE_H

clang/include/clang/Analysis/FlowSensitive/SourceLocations.h

+//===-- SourceLocations.h ---------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines a type alias for collecting source locations of interest.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_SOURCELOCATIONS_H
+#define LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_SOURCELOCATIONS_H
+
+#include "clang/AST/ASTContext.h"
+#include "clang/Analysis/FlowSensitive/DataflowLattice.h"
+#include "clang/Basic/SourceLocation.h"
+#include "llvm/ADT/DenseSet.h"
+#include <string>
+#include <utility>
+
+namespace clang {
+namespace dataflow {
+
+/// Set of source locations.
+using SourceLocations = llvm::DenseSet<SourceLocation>;
+
+/// Returns a string that represents the source locations of the lattice.
+std::string DebugString(const SourceLocations &Locs, const ASTContext &Context);
+
+} // namespace dataflow
+} // namespace clang
+
+#endif // LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_SOURCELOCATIONS_H

clang/include/clang/Analysis/FlowSensitive/SourceLocationsLattice.h

-//===-- SourceLocationsLattice.h --------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-//  This file defines a lattice that collects source locations of interest.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_SOURCELOCATIONS_LATTICE_H
-#define LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_SOURCELOCATIONS_LATTICE_H
-
-#include "clang/AST/ASTContext.h"
-#include "clang/Analysis/FlowSensitive/DataflowLattice.h"
-#include "clang/Basic/SourceLocation.h"
-#include "llvm/ADT/DenseSet.h"
-#include <string>
-#include <utility>
-
-namespace clang {
-namespace dataflow {
-
-/// Lattice for dataflow analysis that keeps track of a set of source locations.
-///
-/// Bottom is the empty set, join is set union, and equality is set equality.
-///
-/// FIXME: Generalize into a (templated) PowerSetLattice.
-class SourceLocationsLattice {
-public:
-  SourceLocationsLattice() = default;
-
-  explicit SourceLocationsLattice(llvm::DenseSet<SourceLocation> Locs)
-      : Locs(std::move(Locs)) {}
-
-  bool operator==(const SourceLocationsLattice &Other) const {
-    return Locs == Other.Locs;
-  }
-
-  bool operator!=(const SourceLocationsLattice &Other) const {
-    return !(*this == Other);
-  }
-
-  LatticeJoinEffect join(const SourceLocationsLattice &Other);
-
-  llvm::DenseSet<SourceLocation> &getSourceLocations() { return Locs; }
-
-  const llvm::DenseSet<SourceLocation> &getSourceLocations() const {
-    return Locs;
-  }
-
-private:
-  llvm::DenseSet<SourceLocation> Locs;
-};
-
-/// Returns a string that represents the source locations of the lattice.
-std::string DebugString(const SourceLocationsLattice &Lattice,
-                        const ASTContext &Context);
-
-} // namespace dataflow
-} // namespace clang
-
-#endif // LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_SOURCELOCATIONS_LATTICE_H

clang/lib/Analysis/FlowSensitive/CMakeLists.txt

 add_clang_library(clangAnalysisFlowSensitive
   ControlFlowContext.cpp
   DataflowAnalysisContext.cpp
   DataflowEnvironment.cpp
-  SourceLocationsLattice.cpp
+  SourceLocations.cpp
   Transfer.cpp
   TypeErasedDataflowAnalysis.cpp
   WatchedLiteralsSolver.cpp
 
   LINK_LIBS
   clangAnalysis
   clangAST
   clangBasic
   )
 
 add_subdirectory(Models)

clang/lib/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/Stmt.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Analysis/FlowSensitive/DataflowEnvironment.h"
 #include "clang/Analysis/FlowSensitive/MatchSwitch.h"
-#include "clang/Analysis/FlowSensitive/SourceLocationsLattice.h"
+#include "clang/Analysis/FlowSensitive/NoopLattice.h"
+#include "clang/Analysis/FlowSensitive/SourceLocations.h"
 #include "clang/Analysis/FlowSensitive/Value.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include <cassert>
 #include <memory>
 #include <utility>
 
 namespace clang {
 namespace dataflow {
 namespace {
 
 using namespace ::clang::ast_matchers;
-using LatticeTransferState = TransferState<SourceLocationsLattice>;
+using LatticeTransferState = TransferState<NoopLattice>;
 
 DeclarationMatcher optionalClass() {
   return classTemplateSpecializationDecl(
       anyOf(hasName("std::optional"), hasName("std::__optional_storage_base"),
             hasName("__optional_destruct_base"), hasName("absl::optional"),
             hasName("base::Optional")),
       hasTemplateArgument(0, refersToType(type().bind("T"))));
 }

 void transferUnwrapCall(const Expr *UnwrapExpr, const Expr *ObjectExpr,
                         LatticeTransferState &State) {
   if (auto *OptionalVal =
           State.Env.getValue(*ObjectExpr, SkipPast::ReferenceThenPointer)) {
     if (State.Env.getStorageLocation(*UnwrapExpr, SkipPast::None) == nullptr)
       if (auto *Loc = maybeInitializeOptionalValueMember(
               UnwrapExpr->getType(), *OptionalVal, State.Env))
         State.Env.setStorageLocation(*UnwrapExpr, *Loc);
-
-    auto *Prop = OptionalVal->getProperty("has_value");
-    if (auto *HasValueVal = cast_or_null<BoolValue>(Prop)) {
-      if (State.Env.flowConditionImplies(*HasValueVal))
-        return;
-    }
-  }
 
-  // Record that this unwrap is *not* provably safe.
-  // FIXME: include either the name of the optional (if applicable) or a source
-  // range of the access for easier interpretation of the result.
-  State.Lattice.getSourceLocations().insert(ObjectExpr->getBeginLoc());
-}
-
 void transferMakeOptionalCall(const CallExpr *E,
                               const MatchFinder::MatchResult &,
                               LatticeTransferState &State) {
   auto &Loc = State.Env.createStorageLocation(*E);
   State.Env.setStorageLocation(*E, Loc);
   State.Env.setValue(
       Loc, createOptionalValue(State.Env, State.Env.getBoolLiteralValue(true)));
 }
void transferStdSwapCall(const CallExpr *E, const MatchFinder::MatchResult &,
 
   auto *OptionalLoc2 =
       State.Env.getStorageLocation(*E->getArg(1), SkipPast::Reference);
   assert(OptionalLoc2 != nullptr);
 
   transferSwap(*OptionalLoc1, *OptionalLoc2, State);
 }
 
+void checkUnwrapCall(const Expr *UnwrapExpr, const Expr *ObjectExpr,
+                     CheckState<SourceLocations> &State) {
+  if (auto *OptionalVal =
+          State.Env.getValue(*ObjectExpr, SkipPast::ReferenceThenPointer)) {
+    auto *Prop = OptionalVal->getProperty("has_value");
+    if (auto *HasValueVal = cast_or_null<BoolValue>(Prop)) {
+      if (State.Env.flowConditionImplies(*HasValueVal))
+        return;
+    }
+  }
+
+  // Record that this unwrap is *not* provably safe.
+  // FIXME: include either the name of the optional (if applicable) or a source
+  // range of the access for easier interpretation of the result.
+  State.Diags.insert(ObjectExpr->getBeginLoc());
+}
+
 llvm::Optional<StatementMatcher>
 ignorableOptional(const UncheckedOptionalAccessModelOptions &Options) {
   if (Options.IgnoreSmartPointerDereference)
     return memberExpr(hasObjectExpression(ignoringParenImpCasts(
         cxxOperatorCallExpr(anyOf(hasOverloadedOperatorName("->"),
                                   hasOverloadedOperatorName("*")),
                             unless(hasArgument(0, expr(hasOptionalType())))))));
   return llvm::None;
 }
 
-auto buildTransferMatchSwitch(
-    const UncheckedOptionalAccessModelOptions &Options) {
-  // FIXME: Evaluate the efficiency of matchers. If using matchers results in a
-  // lot of duplicated work (e.g. string comparisons), consider providing APIs
-  // that avoid it through memoization.
-  auto IgnorableOptional = ignorableOptional(Options);
+auto buildTransferMatchSwitch(StatementMatcher &ValueCall,
+                              StatementMatcher &ValueOperatorCall) {
   return MatchSwitchBuilder<LatticeTransferState>()
       // Attach a symbolic "has_value" state to optional values that we see for
       // the first time.
       .CaseOf<Expr>(
           expr(anyOf(declRefExpr(), memberExpr()), hasOptionalType()),
           initializeOptionalReference)
 
       // make_optional
return MatchSwitchBuilder<LatticeTransferState>()
       // optional::operator=
       .CaseOf<CXXOperatorCallExpr>(isOptionalValueOrConversionAssignment(),
                                    transferValueOrConversionAssignment)
       .CaseOf<CXXOperatorCallExpr>(isOptionalNulloptAssignment(),
                                    transferNulloptAssignment)
 
       // optional::value
       .CaseOf<CXXMemberCallExpr>(
-          isOptionalMemberCallWithName("value", IgnorableOptional),
+          ValueCall,
           [](const CXXMemberCallExpr *E, const MatchFinder::MatchResult &,
              LatticeTransferState &State) {
             transferUnwrapCall(E, E->getImplicitObjectArgument(), State);
           })
 
       // optional::operator*, optional::operator->
-      .CaseOf<CallExpr>(
-          expr(anyOf(isOptionalOperatorCallWithName("*", IgnorableOptional),
-                     isOptionalOperatorCallWithName("->", IgnorableOptional))),
+      .CaseOf<CallExpr>(ValueOperatorCall,
                         [](const CallExpr *E, const MatchFinder::MatchResult &,
                            LatticeTransferState &State) {
                           transferUnwrapCall(E, E->getArg(0), State);
                         })
 
       // optional::has_value
       .CaseOf<CXXMemberCallExpr>(isOptionalMemberCallWithName("has_value"),
                                  transferOptionalHasValueCall)
 
       // optional::operator bool
       .CaseOf<CXXMemberCallExpr>(isOptionalMemberCallWithName("operator bool"),
                                  transferOptionalHasValueCall)
return MatchSwitchBuilder<LatticeTransferState>()
 
       // returns optional
       .CaseOf<CallExpr>(isCallReturningOptional(),
                         transferCallReturningOptional)
 
       .Build();
 }
 
+auto buildCheckMatchSwitch(StatementMatcher &ValueCall,
+                           StatementMatcher &ValueOperatorCall) {
+  return MatchSwitchBuilder<CheckState<SourceLocations>>()
+      // optional::value
+      .CaseOf<CXXMemberCallExpr>(
+          ValueCall,
+          [](const CXXMemberCallExpr *E, const MatchFinder::MatchResult &,
+             CheckState<SourceLocations> &State) {
+            checkUnwrapCall(E, E->getImplicitObjectArgument(), State);
+          })
+
+      // optional::operator*, optional::operator->
+      .CaseOf<CallExpr>(ValueOperatorCall,
+                        [](const CallExpr *E, const MatchFinder::MatchResult &,
+                           CheckState<SourceLocations> &State) {
+                          checkUnwrapCall(E, E->getArg(0), State);
+                        })
+      .Build();
+}
+
+auto buildMatchSwitches(const UncheckedOptionalAccessModelOptions &Options) {
+  // FIXME: Evaluate the efficiency of matchers. If using matchers results in a
+  // lot of duplicated work (e.g. string comparisons), consider providing APIs
+  // that avoid it through memoization.
+  auto IgnorableOptional = ignorableOptional(Options);
+  auto ValueCall = isOptionalMemberCallWithName("value", IgnorableOptional);
+  auto ValueOperatorCall =
+      expr(anyOf(isOptionalOperatorCallWithName("*", IgnorableOptional),
+                 isOptionalOperatorCallWithName("->", IgnorableOptional)));
+  return std::make_pair(buildTransferMatchSwitch(ValueCall, ValueOperatorCall),
+                        buildCheckMatchSwitch(ValueCall, ValueOperatorCall));
+}
+
 } // namespace
 
 ast_matchers::DeclarationMatcher
 UncheckedOptionalAccessModel::optionalClassDecl() {
   return optionalClass();
 }
 
 UncheckedOptionalAccessModel::UncheckedOptionalAccessModel(
     ASTContext &Ctx, UncheckedOptionalAccessModelOptions Options)
-    : DataflowAnalysis<UncheckedOptionalAccessModel, SourceLocationsLattice>(
-          Ctx),
-      TransferMatchSwitch(buildTransferMatchSwitch(Options)) {}
+    : UncheckedOptionalAccessModel(Ctx, buildMatchSwitches(Options)) {}
+
+// We use a delegating constructor to build both `MatchSwitch`es at once while
+// still avoiding unnecessary work by using initializer lists.
+UncheckedOptionalAccessModel::UncheckedOptionalAccessModel(
+    ASTContext &Ctx, std::pair<MatchSwitch<TransferState<NoopLattice>>,
+                               MatchSwitch<CheckState<SourceLocations>>>
+                         MatchSwitches)
+    : DataflowAnalysis<UncheckedOptionalAccessModel, NoopLattice,
+                       SourceLocations>(Ctx),
+      TransferMatchSwitch(MatchSwitches.first),
+      CheckMatchSwitch(MatchSwitches.second) {}
 
-void UncheckedOptionalAccessModel::transfer(const Stmt *S,
-                                            SourceLocationsLattice &L,
+void UncheckedOptionalAccessModel::transfer(const Stmt *S, NoopLattice &L,
                                             Environment &Env) {
   LatticeTransferState State(L, Env);
   TransferMatchSwitch(*S, getASTContext(), State);
 }
 
 bool UncheckedOptionalAccessModel::compareEquivalent(QualType Type,
                                                      const Value &Val1,
                                                      const Environment &Env1,
bool UncheckedOptionalAccessModel::merge(QualType Type, const Value &Val1,
   if (isNonEmptyOptional(Val1, Env1) && isNonEmptyOptional(Val2, Env2))
     MergedEnv.addToFlowCondition(HasValueVal);
   else if (isEmptyOptional(Val1, Env1) && isEmptyOptional(Val2, Env2))
     MergedEnv.addToFlowCondition(MergedEnv.makeNot(HasValueVal));
   setHasValue(MergedVal, HasValueVal);
   return true;
 }
 
+void UncheckedOptionalAccessModel::check(const Stmt *S, SourceLocations &Locs,
+                                         const NoopLattice &,
+                                         const Environment &Env) {
+  CheckState<SourceLocations> State(Locs, Env);
+  CheckMatchSwitch(*S, getASTContext(), State);
+}
+
 } // namespace dataflow
 } // namespace clang

clang/lib/Analysis/FlowSensitive/SourceLocations.cpp

-//===- SourceLocationsLattice.cpp -----------------------------------------===//
+//===- SourceLocations.cpp ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-//  This file implements a lattice that collects source locations of interest.
+//  This file implements a function to stringify source locations of interest.
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/Analysis/FlowSensitive/SourceLocationsLattice.h"
+#include "clang/Analysis/FlowSensitive/SourceLocations.h"
 #include "clang/AST/ASTContext.h"
-#include "clang/Analysis/FlowSensitive/DataflowLattice.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace dataflow {
 
-LatticeJoinEffect
-SourceLocationsLattice::join(const SourceLocationsLattice &Other) {
-  auto SizeBefore = Locs.size();
-  Locs.insert(Other.Locs.begin(), Other.Locs.end());
-  return SizeBefore == Locs.size() ? LatticeJoinEffect::Unchanged
-                                   : LatticeJoinEffect::Changed;
-}
-
-std::string DebugString(const SourceLocationsLattice &Lattice,
+std::string DebugString(const SourceLocations &Locs,
                         const ASTContext &Context) {
-  if (Lattice.getSourceLocations().empty())
+  if (Locs.empty())
     return "";
 
   std::vector<std::string> Locations;
-  Locations.reserve(Lattice.getSourceLocations().size());
-  for (const clang::SourceLocation &Loc : Lattice.getSourceLocations()) {
+  Locations.reserve(Locs.size());
+  for (const clang::SourceLocation &Loc : Locs) {
     Locations.push_back(Loc.printToString(Context.getSourceManager()));
   }
   std::sort(Locations.begin(), Locations.end());
   std::string result;
   llvm::raw_string_ostream OS(result);
   llvm::interleaveComma(Locations, OS);
   return result;
 }
 
 } // namespace dataflow
 } // namespace clang

clang/unittests/Analysis/FlowSensitive/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   FrontendOpenMP
   Support
   )
 
 add_clang_unittest(ClangAnalysisFlowSensitiveTests
   ChromiumCheckModelTest.cpp
   DataflowAnalysisContextTest.cpp
   DataflowEnvironmentTest.cpp
   MapLatticeTest.cpp
   MatchSwitchTest.cpp
   MultiVarConstantPropagationTest.cpp
   SingleVarConstantPropagationTest.cpp
-  SourceLocationsLatticeTest.cpp
   TestingSupport.cpp
   TestingSupportTest.cpp
   TransferTest.cpp
   TypeErasedDataflowAnalysisTest.cpp
   SolverTest.cpp
   UncheckedOptionalAccessModelTest.cpp
   )
 

clang/unittests/Analysis/FlowSensitive/ChromiumCheckModelTest.cpp

ASSERT_THAT_ERROR(
             Code, "target",
             [](ASTContext &C, Environment &) {
               return ModelAdaptorAnalysis<ChromiumCheckModel>(C);
             },
             [&Match](
                 llvm::ArrayRef<
                     std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
                     Results,
-                ASTContext &ASTCtx) { Match(Results, ASTCtx); },
+                NoopDiags &, ASTContext &ASTCtx) { Match(Results, ASTCtx); },
             {"-fsyntax-only", "-fno-delayed-template-parsing", "-std=c++17"},
             FileContents),
         llvm::Succeeded());
   }
 };
 
 TEST_F(ChromiumCheckModelTest, CheckSuccessImpliesConditionHolds) {
   auto Expectations =

clang/unittests/Analysis/FlowSensitive/MatchSwitchTest.cpp

void RunDataflow(llvm::StringRef Code, Matcher Expectations) {
     ASSERT_THAT_ERROR(
         test::checkDataflow<TestAnalysis>(
             Code, "fun",
             [](ASTContext &C, Environment &) { return TestAnalysis(C); },
             [&Expectations](
                 llvm::ArrayRef<std::pair<
                     std::string, DataflowAnalysisState<TestAnalysis::Lattice>>>
                     Results,
+                TestAnalysis::Diags &,
                 ASTContext &) { EXPECT_THAT(Results, Expectations); },
             {"-fsyntax-only", "-std=c++17"}),
         llvm::Succeeded());
   }
 };
 
 TEST_F(MatchSwitchTest, JustX) {
   std::string Code = R"(

clang/unittests/Analysis/FlowSensitive/MultiVarConstantPropagationTest.cpp

ASSERT_THAT_ERROR(
             [](ASTContext &C, Environment &) {
               return ConstantPropagationAnalysis(C);
             },
             [&Expectations](
                 llvm::ArrayRef<std::pair<
                     std::string, DataflowAnalysisState<
                                      ConstantPropagationAnalysis::Lattice>>>
                     Results,
+                ConstantPropagationAnalysis::Diags &,
                 ASTContext &) { EXPECT_THAT(Results, Expectations); },
             {"-fsyntax-only", "-std=c++17"}),
         llvm::Succeeded());
   }
 };
 
 TEST_F(MultiVarConstantPropagationTest, JustInit) {
   std::string Code = R"(

clang/unittests/Analysis/FlowSensitive/NoopAnalysis.h

 
 #ifndef LLVM_CLANG_UNITTESTS_ANALYSIS_FLOWSENSITIVE_NOOPANALYSIS_H
 #define LLVM_CLANG_UNITTESTS_ANALYSIS_FLOWSENSITIVE_NOOPANALYSIS_H
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Stmt.h"
 #include "clang/Analysis/FlowSensitive/DataflowAnalysis.h"
 #include "clang/Analysis/FlowSensitive/DataflowEnvironment.h"
-#include "clang/Analysis/FlowSensitive/DataflowLattice.h"
-#include <ostream>
+#include "clang/Analysis/FlowSensitive/NoopLattice.h"
 
 namespace clang {
 namespace dataflow {
 
-class NoopLattice {
-public:
-  bool operator==(const NoopLattice &) const { return true; }
-
-  LatticeJoinEffect join(const NoopLattice &) {
-    return LatticeJoinEffect::Unchanged;
-  }
-};
-
-inline std::ostream &operator<<(std::ostream &OS, const NoopLattice &) {
-  return OS << "noop";
-}
-
 class NoopAnalysis : public DataflowAnalysis<NoopAnalysis, NoopLattice> {
 public:
   /// `ApplyBuiltinTransfer` controls whether to run the built-in transfer
   /// functions that model memory during the analysis. Their results are not
   /// used by `NoopAnalysis`, but tests that need to inspect the environment
   /// should enable them.
   NoopAnalysis(ASTContext &Context, bool ApplyBuiltinTransfer)
       : DataflowAnalysis<NoopAnalysis, NoopLattice>(Context,

clang/unittests/Analysis/FlowSensitive/SingleVarConstantPropagationTest.cpp

ASSERT_THAT_ERROR(
             [](ASTContext &C, Environment &) {
               return ConstantPropagationAnalysis(C);
             },
             [&Expectations](
                 llvm::ArrayRef<std::pair<
                     std::string, DataflowAnalysisState<
                                      ConstantPropagationAnalysis::Lattice>>>
                     Results,
+                ConstantPropagationAnalysis::Diags &,
                 ASTContext &) { EXPECT_THAT(Results, Expectations); },
             {"-fsyntax-only", "-std=c++17"}),
         llvm::Succeeded());
   }
 };
 
 TEST_F(ConstantPropagationTest, JustInit) {
   std::string Code = R"(

clang/unittests/Analysis/FlowSensitive/SourceLocationsLatticeTest.cpp

-//===- unittests/Analysis/FlowSensitive/SourceLocationsLatticeTest.cpp ----===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "clang/Analysis/FlowSensitive/SourceLocationsLattice.h"
-
-#include "clang/Analysis/FlowSensitive/DataflowLattice.h"
-#include "clang/Basic/SourceLocation.h"
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-namespace clang {
-namespace dataflow {
-namespace {
-
-TEST(SourceLocationsLatticeTest, Comparison) {
-  const SourceLocationsLattice Bottom;
-  const SourceLocationsLattice NonBottom(
-      {SourceLocation::getFromRawEncoding(0)});
-
-  EXPECT_TRUE(Bottom == Bottom);
-  EXPECT_FALSE(Bottom == NonBottom);
-  EXPECT_FALSE(NonBottom == Bottom);
-  EXPECT_TRUE(NonBottom == NonBottom);
-
-  EXPECT_FALSE(Bottom != Bottom);
-  EXPECT_TRUE(Bottom != NonBottom);
-  EXPECT_TRUE(NonBottom != Bottom);
-  EXPECT_FALSE(NonBottom != NonBottom);
-}
-
-TEST(SourceLocationsLatticeTest, Join) {
-  const SourceLocationsLattice Bottom;
-  const SourceLocationsLattice NonBottom(
-      {SourceLocation::getFromRawEncoding(0)});
-  {
-    SourceLocationsLattice LHS = Bottom;
-    const SourceLocationsLattice RHS = Bottom;
-    EXPECT_EQ(LHS.join(RHS), LatticeJoinEffect::Unchanged);
-    EXPECT_EQ(LHS, Bottom);
-  }
-  {
-    SourceLocationsLattice LHS = NonBottom;
-    const SourceLocationsLattice RHS = Bottom;
-    EXPECT_EQ(LHS.join(RHS), LatticeJoinEffect::Unchanged);
-    EXPECT_EQ(LHS, NonBottom);
-  }
-  {
-    SourceLocationsLattice LHS = Bottom;
-    const SourceLocationsLattice RHS = NonBottom;
-    EXPECT_EQ(LHS.join(RHS), LatticeJoinEffect::Changed);
-    EXPECT_EQ(LHS, NonBottom);
-  }
-  {
-    SourceLocationsLattice LHS = NonBottom;
-    const SourceLocationsLattice RHS = NonBottom;
-    EXPECT_EQ(LHS.join(RHS), LatticeJoinEffect::Unchanged);
-    EXPECT_EQ(LHS, NonBottom);
-  }
-}
-
-} // namespace
-} // namespace dataflow
-} // namespace clang

clang/unittests/Analysis/FlowSensitive/TestingSupport.h

 
 // Returns assertions based on annotations that are present after statements in
 // `AnnotatedCode`.
 llvm::Expected<llvm::DenseMap<const Stmt *, std::string>>
 buildStatementToAnnotationMapping(const FunctionDecl *Func,
                                   llvm::Annotations AnnotatedCode);
 
 // Runs dataflow on the body of the function that matches `func_matcher` in code
-// snippet `code`. Requires: `Analysis` contains a type `Lattice`.
+// snippet `code`. Requires: `Analysis` contains types `Lattice` and `Diags`.
 template <typename AnalysisT>
 llvm::Error checkDataflow(
     llvm::StringRef Code,
     ast_matchers::internal::Matcher<FunctionDecl> FuncMatcher,
     std::function<AnalysisT(ASTContext &, Environment &)> MakeAnalysis,
     std::function<void(
         llvm::ArrayRef<std::pair<
             std::string, DataflowAnalysisState<typename AnalysisT::Lattice>>>,
-        ASTContext &)>
+        typename AnalysisT::Diags &, ASTContext &)>
         Expectations,
     ArrayRef<std::string> Args,
     const tooling::FileContentMappings &VirtualMappedFiles = {}) {
   using StateT = DataflowAnalysisState<typename AnalysisT::Lattice>;
 
   llvm::Annotations AnnotatedCode(Code);
   auto Unit = tooling::buildASTFromCodeWithArgs(
       AnnotatedCode.code(), Args, "input.cc", "clang-dataflow-test",
       std::make_shared<PCHContainerOperations>(),
       tooling::getClangStripDependencyFileAdjuster(), VirtualMappedFiles);
llvm::Error checkDataflow(
 
   auto CFCtx = ControlFlowContext::build(F, F->getBody(), &F->getASTContext());
   if (!CFCtx)
     return CFCtx.takeError();
 
   DataflowAnalysisContext DACtx(std::make_unique<WatchedLiteralsSolver>());
   Environment Env(DACtx, *F);
   auto Analysis = MakeAnalysis(Context, Env);
 
   llvm::Expected<llvm::DenseMap<const clang::Stmt *, std::string>>
       StmtToAnnotations = buildStatementToAnnotationMapping(F, AnnotatedCode);
   if (!StmtToAnnotations)
     return StmtToAnnotations.takeError();
   auto &Annotations = *StmtToAnnotations;
 
   llvm::Expected<std::vector<llvm::Optional<TypeErasedDataflowAnalysisState>>>
       MaybeBlockStates = runTypeErasedDataflowAnalysis(*CFCtx, Analysis, Env);
   if (!MaybeBlockStates)
     return MaybeBlockStates.takeError();
   auto &BlockStates = *MaybeBlockStates;
 
+  typename AnalysisT::Diags Diags;
+
   if (BlockStates.empty()) {
-    Expectations({}, Context);
+    Expectations({}, Diags, Context);
     return llvm::Error::success();
   }
 
   // Compute a map from statement annotations to the state computed for
   // the program point immediately after the annotated statement.
   std::vector<std::pair<std::string, StateT>> Results;
   for (const CFGBlock *Block : CFCtx->getCFG()) {
     // Skip blocks that were not evaluated.
     if (!BlockStates[Block->getBlockID()].hasValue())
       continue;
 
     transferBlock(
         *CFCtx, BlockStates, *Block, Env, Analysis,
-        [&Results, &Annotations](const clang::CFGStmt &Stmt,
-                                 const TypeErasedDataflowAnalysisState &State) {
-          auto It = Annotations.find(Stmt.getStmt());
-          if (It == Annotations.end())
-            return;
+        [&Results, &Diags, &Annotations,
+         &Analysis](const clang::CFGStmt &Stmt,
+          auto S = Stmt.getStmt();
           auto *Lattice =
               llvm::any_cast<typename AnalysisT::Lattice>(&State.Lattice.Value);
+          Analysis.check(S, Diags, *Lattice, State.Env);
+
+          auto It = Annotations.find(S);
+          if (It == Annotations.end())
+            return;
           Results.emplace_back(It->second, StateT{*Lattice, State.Env});
         });
   }
-  Expectations(Results, Context);
+  Expectations(Results, Diags, Context);
   return llvm::Error::success();
 }
 
 // Runs dataflow on the body of the function named `target_fun` in code snippet
 // `code`.
 template <typename AnalysisT>
 llvm::Error checkDataflow(
     llvm::StringRef Code, llvm::StringRef TargetFun,
     std::function<AnalysisT(ASTContext &, Environment &)> MakeAnalysis,
     std::function<void(
         llvm::ArrayRef<std::pair<
             std::string, DataflowAnalysisState<typename AnalysisT::Lattice>>>,
-        ASTContext &)>
+        typename AnalysisT::Diags &, ASTContext &)>
         Expectations,
     ArrayRef<std::string> Args,
     const tooling::FileContentMappings &VirtualMappedFiles = {}) {
   return checkDataflow(Code, ast_matchers::hasName(TargetFun),
                        std::move(MakeAnalysis), std::move(Expectations), Args,
                        VirtualMappedFiles);
 }
 
 /// Returns the `ValueDecl` for the given identifier.
 ///
 /// Requirements:
 ///
 ///  `Name` must be unique in `ASTCtx`.
 const ValueDecl *findValueDecl(ASTContext &ASTCtx, llvm::StringRef Name);
 
 } // namespace test
 } // namespace dataflow
 } // namespace clang
 
 #endif // LLVM_CLANG_ANALYSIS_FLOW_SENSITIVE_TESTING_SUPPORT_H_

clang/unittests/Analysis/FlowSensitive/TestingSupportTest.cpp

)",
             EXPECT_EQ(Annotations.begin()->second, "ok");
           });
 }
 
 void checkDataflow(
     llvm::StringRef Code, llvm::StringRef Target,
     std::function<void(llvm::ArrayRef<std::pair<
                            std::string, DataflowAnalysisState<NoopLattice>>>,
-                       ASTContext &)>
+                       NoopDiags &, ASTContext &)>
         Expectations) {
   ASSERT_THAT_ERROR(
       test::checkDataflow<NoopAnalysis>(
           Code, Target,
           [](ASTContext &Context, Environment &) {
             return NoopAnalysis(Context, /*ApplyBuiltinTransfer=*/false);
           },
           std::move(Expectations), {"-fsyntax-only", "-std=c++17"}),
       llvm::Succeeded());
 }
 
 TEST(ProgramPointAnnotations, NoAnnotations) {
   ::testing::MockFunction<void(
       llvm::ArrayRef<
           std::pair<std::string, DataflowAnalysisState<NoopLattice>>>,
-      ASTContext &)>
+      NoopDiags &, ASTContext &)>
       Expectations;
 
-  EXPECT_CALL(Expectations, Call(IsEmpty(), _)).Times(1);
+  EXPECT_CALL(Expectations, Call(IsEmpty(), _, _)).Times(1);
 
   checkDataflow("void target() {}", "target", Expectations.AsStdFunction());
 }
 
 TEST(ProgramPointAnnotations, NoAnnotationsDifferentTarget) {
   ::testing::MockFunction<void(
       llvm::ArrayRef<
           std::pair<std::string, DataflowAnalysisState<NoopLattice>>>,
-      ASTContext &)>
+      NoopDiags &, ASTContext &)>
       Expectations;
 
-  EXPECT_CALL(Expectations, Call(IsEmpty(), _)).Times(1);
+  EXPECT_CALL(Expectations, Call(IsEmpty(), _, _)).Times(1);
 
   checkDataflow("void fun() {}", "fun", Expectations.AsStdFunction());
 }
 
 TEST(ProgramPointAnnotations, WithCodepoint) {
   ::testing::MockFunction<void(
       llvm::ArrayRef<
           std::pair<std::string, DataflowAnalysisState<NoopLattice>>>,
-      ASTContext &)>
+      NoopDiags &, ASTContext &)>
       Expectations;
 
   EXPECT_CALL(Expectations,
-              Call(UnorderedElementsAre(Pair("program-point", _)), _))
+              Call(UnorderedElementsAre(Pair("program-point", _)), _, _))
       .Times(1);
 
   checkDataflow(R"cc(void target() {
                      int n;
                      // [[program-point]]
                    })cc",
                 "target", Expectations.AsStdFunction());
 }
 
 TEST(ProgramPointAnnotations, MultipleCodepoints) {
   ::testing::MockFunction<void(
       llvm::ArrayRef<
           std::pair<std::string, DataflowAnalysisState<NoopLattice>>>,
-      ASTContext &)>
+      NoopDiags &, ASTContext &)>
       Expectations;
 
   EXPECT_CALL(Expectations,
               Call(UnorderedElementsAre(Pair("program-point-1", _),
                                         Pair("program-point-2", _)),
-                   _))
+                   _, _))
       .Times(1);
 
   checkDataflow(R"cc(void target(bool b) {
                      if (b) {
                        int n;
                        // [[program-point-1]]
                      } else {
                        int m;
                        // [[program-point-2]]
                      }
                    })cc",
                 "target", Expectations.AsStdFunction());
 }
 
 } // namespace

clang/unittests/Analysis/FlowSensitive/TransferTest.cpp

ASSERT_THAT_ERROR(
             Code, TargetFun,
             [ApplyBuiltinTransfer](ASTContext &C, Environment &) {
               return NoopAnalysis(C, ApplyBuiltinTransfer);
             },
             [&Match](
                 llvm::ArrayRef<
                     std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
                     Results,
-                ASTContext &ASTCtx) { Match(Results, ASTCtx); },
+                NoopDiags &, ASTContext &ASTCtx) { Match(Results, ASTCtx); },
             {"-fsyntax-only", "-fno-delayed-template-parsing",
              "-std=" +
                  std::string(
                      LangStandard::getLangStandardForKind(Std).getName())}),
         llvm::Succeeded());
   }
 };
 
ASSERT_THAT_ERROR(
       test::checkDataflow<NoopAnalysis>(
           Code, cxxConstructorDecl(ofClass(hasName("B"))),
           [](ASTContext &C, Environment &) {
             return NoopAnalysis(C, /*ApplyBuiltinTransfer=*/true);
           },
           [](llvm::ArrayRef<
                  std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
                  Results,
-             ASTContext &ASTCtx) {
+             NoopDiags &, ASTContext &ASTCtx) {
             // Regression test to verify that base-class initializers do not
             // trigger an assertion. If we add support for such initializers in
             // the future, we can expand this test to check more specific
             // properties.
             EXPECT_THAT(Results, ElementsAre(Pair("p", _)));
           },
           {"-fsyntax-only", "-fno-delayed-template-parsing",
            "-std=" + std::string(LangStandard::getLangStandardForKind(

clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp

ASSERT_THAT_ERROR(
             Code, "target",
             [](ASTContext &C, Environment &) {
               return FunctionCallAnalysis(C);
             },
             [&Expectations](
                 llvm::ArrayRef<std::pair<
                     std::string, DataflowAnalysisState<FunctionCallLattice>>>
                     Results,
+                NoopDiags &,
                 ASTContext &) { EXPECT_THAT(Results, Expectations); },
             {"-fsyntax-only", "-std=c++17"}, FilesContents),
         llvm::Succeeded());
   }
 };
 
 MATCHER_P(HoldsFunctionCallLattice, m,
           ((negation ? "doesn't hold" : "holds") +
ASSERT_THAT_ERROR(
             Code, "target",
             [](ASTContext &Context, Environment &Env) {
               return SpecialBoolAnalysis(Context);
             },
             [&Match](
                 llvm::ArrayRef<
                     std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
                     Results,
-                ASTContext &ASTCtx) { Match(Results, ASTCtx); },
+                NoopDiags &, ASTContext &ASTCtx) { Match(Results, ASTCtx); },
             {"-fsyntax-only", "-std=c++17"}),
         llvm::Succeeded());
   }
 };
 
 TEST_F(JoinFlowConditionsTest, JoinDistinctButProvablyEquivalentValues) {
   std::string Code = R"(
     struct SpecialBool {
ASSERT_THAT_ERROR(
               HasValueTop =
                   &Env.takeOwnership(std::make_unique<AtomicBoolValue>());
               return OptionalIntAnalysis(Context, *HasValueTop);
             },
             [&Match](
                 llvm::ArrayRef<
                     std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
                     Results,
-                ASTContext &ASTCtx) { Match(Results, ASTCtx); },
+                NoopDiags &, ASTContext &ASTCtx) { Match(Results, ASTCtx); },
             {"-fsyntax-only", "-std=c++17"}, FilesContents),
         llvm::Succeeded());
   }
 
   BoolValue *HasValueTop = nullptr;
 };
 
 TEST_F(WideningTest, JoinDistinctValuesWithDistinctProperties) {
ASSERT_THAT_ERROR(
             Code, "target",
             [](ASTContext &Context, Environment &Env) {
               return NoopAnalysis(Context, true);
             },
             [&Match](
                 llvm::ArrayRef<
                     std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
                     Results,
-                ASTContext &ASTCtx) { Match(Results, ASTCtx); },
+                NoopDiags &, ASTContext &ASTCtx) { Match(Results, ASTCtx); },
             {"-fsyntax-only", "-std=c++17"}),
         llvm::Succeeded());
   }
 };
 
 TEST_F(FlowConditionTest, IfStmtSingleVar) {
   std::string Code = R"(
     void target(bool Foo) {

clang/unittests/Analysis/FlowSensitive/UncheckedOptionalAccessModelTest.cpp

 //===- UncheckedOptionalAccessModelTest.cpp -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // FIXME: Move this to clang/unittests/Analysis/FlowSensitive/Models.
 
 #include "clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h"
 #include "TestingSupport.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
-#include "clang/Analysis/FlowSensitive/SourceLocationsLattice.h"
+#include "clang/Analysis/FlowSensitive/SourceLocations.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Error.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <string>
 #include <utility>
 #include <vector>
 
 using namespace clang;
 using namespace dataflow;
 using namespace test;
 
-using ::testing::Pair;
-using ::testing::UnorderedElementsAre;
-
 // FIXME: Move header definitions in separate file(s).
 static constexpr char CSDtdDefHeader[] = R"(
 #ifndef CSTDDEF_H
 #define CSTDDEF_H
 
 namespace std {
 
 typedef decltype(sizeof(char)) size_t;

 template <typename T, typename U, typename... Args>
 constexpr Optional<T> make_optional(std::initializer_list<U> il,
                                     Args&&... args);
 
 } // namespace base
 )";
 
 /// Converts `L` to string.
-static std::string ConvertToString(const SourceLocationsLattice &L,
+static std::string ConvertToString(const SourceLocations &L,
                                    const ASTContext &Ctx) {
-  return L.getSourceLocations().empty() ? "safe"
-                                        : "unsafe: " + DebugString(L, Ctx);
+  return L.empty() ? "safe" : "unsafe: " + DebugString(L, Ctx);
 }
 
 /// Replaces all occurrences of `Pattern` in `S` with `Replacement`.
 static void ReplaceAllOccurrences(std::string &S, const std::string &Pattern,
                                   const std::string &Replacement) {
   size_t Pos = 0;
   while (true) {
     Pos = S.find(Pattern, Pos);
void ExpectLatticeChecksFor(std::string SourceCode,
     llvm::Error Error = checkDataflow<UncheckedOptionalAccessModel>(
         SourceCode, FuncMatcher,
         [](ASTContext &Ctx, Environment &) {
           return UncheckedOptionalAccessModel(
               Ctx, UncheckedOptionalAccessModelOptions{
                        /*IgnoreSmartPointerDereference=*/true});
         },
         [&MatchesLatticeChecks](
-            llvm::ArrayRef<std::pair<
-                std::string, DataflowAnalysisState<SourceLocationsLattice>>>
-                CheckToLatticeMap,
-            ASTContext &Ctx) {
-          // FIXME: Consider using a matcher instead of translating
-          // `CheckToLatticeMap` to `CheckToStringifiedLatticeMap`.
-          std::vector<std::pair<std::string, std::string>>
-              CheckToStringifiedLatticeMap;
-          for (const auto &E : CheckToLatticeMap) {
-            CheckToStringifiedLatticeMap.emplace_back(
-                E.first, ConvertToString(E.second.Lattice, Ctx));
-          }
-          EXPECT_THAT(CheckToStringifiedLatticeMap, MatchesLatticeChecks);
+            llvm::ArrayRef<
+                std::pair<std::string, DataflowAnalysisState<NoopLattice>>>,
+            SourceLocations &Locs, ASTContext &Ctx) {
+          std::string StringifiedDiags = ConvertToString(Locs, Ctx);
+          EXPECT_THAT(StringifiedDiags, MatchesLatticeChecks);
         },
         {"-fsyntax-only", "-std=c++17", "-Wno-undefined-inline"}, FileContents);
     if (Error)
       FAIL() << llvm::toString(std::move(Error));
   }
 };
 
 INSTANTIATE_TEST_SUITE_P(
     UncheckedOptionalUseTestInst, UncheckedOptionalAccessTest,
     ::testing::Values(OptionalTypeIdentifier{"std", "optional"},
                       OptionalTypeIdentifier{"absl", "optional"},
                       OptionalTypeIdentifier{"base", "Optional"}),
     [](const ::testing::TestParamInfo<OptionalTypeIdentifier> &Info) {
       return Info.param.NamespaceName;
     });
 
 TEST_P(UncheckedOptionalAccessTest, EmptyFunctionBody) {
   ExpectLatticeChecksFor(R"(
     void target() {
       (void)0;
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 }
 
 TEST_P(UncheckedOptionalAccessTest, UnwrapUsingValueNoCheck) {
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     void target($ns::$optional<int> opt) {
       opt.value();
       /*[[check]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check", "unsafe: input.cc:5:7")));
+      "unsafe: input.cc:5:7");
 
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     void target($ns::$optional<int> opt) {
       std::move(opt).value();
       /*[[check]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check", "unsafe: input.cc:5:7")));
+      "unsafe: input.cc:5:7");
 }
 
 TEST_P(UncheckedOptionalAccessTest, UnwrapUsingOperatorStarNoCheck) {
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     void target($ns::$optional<int> opt) {
       *opt;
       /*[[check]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check", "unsafe: input.cc:5:8")));
+      "unsafe: input.cc:5:8");
 
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     void target($ns::$optional<int> opt) {
       *std::move(opt);
       /*[[check]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check", "unsafe: input.cc:5:8")));
+      "unsafe: input.cc:5:8");
 }
 
 TEST_P(UncheckedOptionalAccessTest, UnwrapUsingOperatorArrowNoCheck) {
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     struct Foo {
       void foo();
     };
 
     void target($ns::$optional<Foo> opt) {
       opt->foo();
       /*[[check]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check", "unsafe: input.cc:9:7")));
+      "unsafe: input.cc:9:7");
 
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     struct Foo {
       void foo();
     };
 
     void target($ns::$optional<Foo> opt) {
       std::move(opt)->foo();
       /*[[check]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check", "unsafe: input.cc:9:7")));
+      "unsafe: input.cc:9:7");
 }
 
 TEST_P(UncheckedOptionalAccessTest, HasValueCheck) {
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     void target($ns::$optional<int> opt) {
       if (opt.has_value()) {
         opt.value();
         /*[[check]]*/
       }
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 }
 
 TEST_P(UncheckedOptionalAccessTest, OperatorBoolCheck) {
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     void target($ns::$optional<int> opt) {
       if (opt) {
         opt.value();
         /*[[check]]*/
       }
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 }
 
 TEST_P(UncheckedOptionalAccessTest, UnwrapFunctionCallResultNoCheck) {
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     void target() {
       Make<$ns::$optional<int>>().value();
       (void)0;
       /*[[check]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check", "unsafe: input.cc:5:7")));
+      "unsafe: input.cc:5:7");
 
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     void target($ns::$optional<int> opt) {
       std::move(opt).value();
       /*[[check]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check", "unsafe: input.cc:5:7")));
+      "unsafe: input.cc:5:7");
 }
 
 TEST_P(UncheckedOptionalAccessTest, DefaultConstructor) {
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     void target() {
       $ns::$optional<int> opt;
       opt.value();
       /*[[check]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check", "unsafe: input.cc:6:7")));
+      "unsafe: input.cc:6:7");
 }
 
 TEST_P(UncheckedOptionalAccessTest, NulloptConstructor) {
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     void target() {
       $ns::$optional<int> opt($ns::nullopt);
       opt.value();
       /*[[check]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check", "unsafe: input.cc:6:7")));
+      "unsafe: input.cc:6:7");
 }
 
 TEST_P(UncheckedOptionalAccessTest, InPlaceConstructor) {
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     void target() {
       $ns::$optional<int> opt($ns::in_place, 3);
       opt.value();
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     struct Foo {};
 
     void target() {
       $ns::$optional<Foo> opt($ns::in_place);
       opt.value();
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     struct Foo {
       explicit Foo(int, bool);
     };
 
     void target() {
       $ns::$optional<Foo> opt($ns::in_place, 3, false);
       opt.value();
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     struct Foo {
       explicit Foo(std::initializer_list<int>);
     };
 
     void target() {
       $ns::$optional<Foo> opt($ns::in_place, {3});
       opt.value();
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 }
 
 TEST_P(UncheckedOptionalAccessTest, ValueConstructor) {
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     void target() {
       $ns::$optional<int> opt(21);
       opt.value();
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     void target() {
       $ns::$optional<int> opt = $ns::$optional<int>(21);
       opt.value();
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     void target() {
       $ns::$optional<$ns::$optional<int>> opt(Make<$ns::$optional<int>>());
       opt.value();
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     struct MyString {
       MyString(const char*);
     };
 
     void target() {
       $ns::$optional<MyString> opt("foo");
       opt.value();
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     struct Foo {};
 
     struct Bar {
       Bar(const Foo&);
     };
 
     void target() {
       $ns::$optional<Bar> opt(Make<Foo>());
       opt.value();
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     struct Foo {
       explicit Foo(int);
     };
 
     void target() {
       $ns::$optional<Foo> opt(3);
       opt.value();
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                        "safe");
 }
 
 TEST_P(UncheckedOptionalAccessTest, ConvertibleOptionalConstructor) {
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     struct Foo {};
 
     struct Bar {
       Bar(const Foo&);
     };
 
     void target() {
       $ns::$optional<Bar> opt(Make<$ns::$optional<Foo>>());
       opt.value();
       /*[[check]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check", "unsafe: input.cc:12:7")));
+      "unsafe: input.cc:12:7");
 
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     struct Foo {};
 
     struct Bar {
       explicit Bar(const Foo&);
     };
 
     void target() {
       $ns::$optional<Bar> opt(Make<$ns::$optional<Foo>>());
       opt.value();
       /*[[check]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check", "unsafe: input.cc:12:7")));
+      "unsafe: input.cc:12:7");
 
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     struct Foo {};
 
     struct Bar {
       Bar(const Foo&);
     };
 
     void target() {
       $ns::$optional<Foo> opt1 = $ns::nullopt;
       $ns::$optional<Bar> opt2(opt1);
       opt2.value();
       /*[[check]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check", "unsafe: input.cc:13:7")));
+      "unsafe: input.cc:13:7");
 
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     struct Foo {};
 
     struct Bar {
       Bar(const Foo&);
     };
 
     void target() {
       $ns::$optional<Foo> opt1(Make<Foo>());
       $ns::$optional<Bar> opt2(opt1);
       opt2.value();
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     struct Foo {};
 
     struct Bar {
       explicit Bar(const Foo&);
     };
 
     void target() {
       $ns::$optional<Foo> opt1(Make<Foo>());
       $ns::$optional<Bar> opt2(opt1);
       opt2.value();
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 }
 
 TEST_P(UncheckedOptionalAccessTest, MakeOptional) {
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     void target() {
       $ns::$optional<int> opt = $ns::make_optional(0);
       opt.value();
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     struct Foo {
       Foo(int, int);
     };
 
     void target() {
       $ns::$optional<Foo> opt = $ns::make_optional<Foo>(21, 22);
       opt.value();
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     struct Foo {
       constexpr Foo(std::initializer_list<char>);
     };
 
     void target() {
       char a = 'a';
       $ns::$optional<Foo> opt = $ns::make_optional<Foo>({a});
       opt.value();
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 }
 
 TEST_P(UncheckedOptionalAccessTest, ValueOr) {
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     void target() {
       $ns::$optional<int> opt;
       opt.value_or(0);
       (void)0;
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 }
 
 TEST_P(UncheckedOptionalAccessTest, ValueOrComparison) {
   // Pointers.
   ExpectLatticeChecksFor(
       R"code(
     #include "unchecked_optional_access_test.h"
 
     void target($ns::$optional<int*> opt) {
       if (opt.value_or(nullptr) != nullptr) {
         opt.value();
         /*[[check-ptrs-1]]*/
       } else {
         opt.value();
         /*[[check-ptrs-2]]*/
       }
     }
   )code",
-      UnorderedElementsAre(Pair("check-ptrs-1", "safe"),
-                           Pair("check-ptrs-2", "unsafe: input.cc:9:9")));
+      "unsafe: input.cc:9:9");
 
   // Integers.
   ExpectLatticeChecksFor(
       R"code(
     #include "unchecked_optional_access_test.h"
 
     void target($ns::$optional<int> opt) {
       if (opt.value_or(0) != 0) {
         opt.value();
         /*[[check-ints-1]]*/
       } else {
         opt.value();
         /*[[check-ints-2]]*/
       }
     }
   )code",
-      UnorderedElementsAre(Pair("check-ints-1", "safe"),
-                           Pair("check-ints-2", "unsafe: input.cc:9:9")));
+      "unsafe: input.cc:9:9");
 
   // Strings.
   ExpectLatticeChecksFor(
       R"code(
     #include "unchecked_optional_access_test.h"
 
     void target($ns::$optional<std::string> opt) {
       if (!opt.value_or("").empty()) {
         opt.value();
         /*[[check-strings-1]]*/
       } else {
         opt.value();
         /*[[check-strings-2]]*/
       }
     }
   )code",
-      UnorderedElementsAre(Pair("check-strings-1", "safe"),
-                           Pair("check-strings-2", "unsafe: input.cc:9:9")));
+      "unsafe: input.cc:9:9");
 
   ExpectLatticeChecksFor(
       R"code(
     #include "unchecked_optional_access_test.h"
 
     void target($ns::$optional<std::string> opt) {
       if (opt.value_or("") != "") {
         opt.value();
         /*[[check-strings-neq-1]]*/
       } else {
         opt.value();
         /*[[check-strings-neq-2]]*/
       }
     }
   )code",
-      UnorderedElementsAre(
-          Pair("check-strings-neq-1", "safe"),
-          Pair("check-strings-neq-2", "unsafe: input.cc:9:9")));
+      "unsafe: input.cc:9:9");
 
   // Pointer-to-optional.
   //
   // FIXME: make `opt` a parameter directly, once we ensure that all `optional`
   // values have a `has_value` property.
   ExpectLatticeChecksFor(
       R"code(
     #include "unchecked_optional_access_test.h"
 
     void target($ns::$optional<int> p) {
       $ns::$optional<int> *opt = &p;
       if (opt->value_or(0) != 0) {
         opt->value();
         /*[[check-pto-1]]*/
       } else {
         opt->value();
         /*[[check-pto-2]]*/
       }
     }
   )code",
-      UnorderedElementsAre(Pair("check-pto-1", "safe"),
-                           Pair("check-pto-2", "unsafe: input.cc:10:9")));
+      "unsafe: input.cc:10:9");
 }
 
 TEST_P(UncheckedOptionalAccessTest, Emplace) {
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     void target() {
       $ns::$optional<int> opt;
       opt.emplace(0);
       opt.value();
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     void target($ns::$optional<int> *opt) {
       opt->emplace(0);
       opt->value();
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 
   // FIXME: Add tests that call `emplace` in conditional branches:
   //  ExpectLatticeChecksFor(
   //      R"(
   //    #include "unchecked_optional_access_test.h"
   //
   //    void target($ns::$optional<int> opt, bool b) {
   //      if (b) {
   //        opt.emplace(0);
   //      }
   //      if (b) {
   //        opt.value();
   //        /*[[check-1]]*/
   //      } else {
   //        opt.value();
   //        /*[[check-2]]*/
   //      }
   //    }
   //  )",
-  //      UnorderedElementsAre(Pair("check-1", "safe"),
-  //                           Pair("check-2", "unsafe: input.cc:12:9")));
+  //      "unsafe: input.cc:12:9");
 }
 
 TEST_P(UncheckedOptionalAccessTest, Reset) {
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     void target() {
       $ns::$optional<int> opt = $ns::make_optional(0);
       opt.reset();
       opt.value();
       /*[[check]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check", "unsafe: input.cc:7:7")));
+      "unsafe: input.cc:7:7");
 
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     void target($ns::$optional<int> &opt) {
       if (opt.has_value()) {
         opt.reset();
         opt.value();
         /*[[check]]*/
       }
     }
   )",
-      UnorderedElementsAre(Pair("check", "unsafe: input.cc:7:9")));
+      "unsafe: input.cc:7:9");
 
   // FIXME: Add tests that call `reset` in conditional branches:
   //  ExpectLatticeChecksFor(
   //      R"(
   //    #include "unchecked_optional_access_test.h"
   //
   //    void target(bool b) {
   //      $ns::$optional<int> opt = $ns::make_optional(0);
   //      if (b) {
   //        opt.reset();
   //      }
   //      if (b) {
   //        opt.value();
   //        /*[[check-1]]*/
   //      } else {
   //        opt.value();
   //        /*[[check-2]]*/
   //      }
   //    }
   //  )",
-  //      UnorderedElementsAre(Pair("check-1", "unsafe: input.cc:10:9"),
-  //                           Pair("check-2", "safe")));
+  //      "safe");
 }
 
 TEST_P(UncheckedOptionalAccessTest, ValueAssignment) {
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     struct Foo {};
 
     void target() {
       $ns::$optional<Foo> opt;
       opt = Foo();
       opt.value();
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     struct Foo {};
 
     void target() {
       $ns::$optional<Foo> opt;
       (opt = Foo()).value();
       (void)0;
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     struct MyString {
       MyString(const char*);
     };
 
     void target() {
       $ns::$optional<MyString> opt;
       opt = "foo";
       opt.value();
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     struct MyString {
       MyString(const char*);
     };
 
     void target() {
       $ns::$optional<MyString> opt;
       (opt = "foo").value();
       /*[[check]]*/
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 }
 
 TEST_P(UncheckedOptionalAccessTest, OptionalConversionAssignment) {
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     struct Foo {};
 
     struct Bar {
       Bar(const Foo&);
     };
 
     void target() {
       $ns::$optional<Foo> opt1 = Foo();
       $ns::$optional<Bar> opt2;
       opt2 = opt1;
       opt2.value();
       /*[[check]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check", "safe")));
+      "safe");
 
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     struct Foo {};
 
     struct Bar {
       Bar(const Foo&);
     };
 
     void target() {
       $ns::$optional<Foo> opt1;
       $ns::$optional<Bar> opt2;
       if (opt2.has_value()) {
         opt2 = opt1;
         opt2.value();
         /*[[check]]*/
       }
     }
   )",
-      UnorderedElementsAre(Pair("check", "unsafe: input.cc:15:9")));
+      "unsafe: input.cc:15:9");
 
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     struct Foo {};
 
     struct Bar {
       Bar(const Foo&);
     };
 
     void target() {
       $ns::$optional<Foo> opt1 = Foo();
       $ns::$optional<Bar> opt2;
       (opt2 = opt1).value();
       (void)0;
       /*[[check]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check", "safe")));
+      "safe");
 }
 
 TEST_P(UncheckedOptionalAccessTest, NulloptAssignment) {
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     void target() {
       $ns::$optional<int> opt = 3;
       opt = $ns::nullopt;
       opt.value();
       /*[[check]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check", "unsafe: input.cc:7:7")));
+      "unsafe: input.cc:7:7");
 
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     void target() {
       $ns::$optional<int> opt = 3;
       (opt = $ns::nullopt).value();
       /*[[check]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check", "unsafe: input.cc:6:7")));
+      "unsafe: input.cc:6:7");
 }
 
 TEST_P(UncheckedOptionalAccessTest, OptionalSwap) {
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     void target() {
       $ns::$optional<int> opt1 = $ns::nullopt;
       $ns::$optional<int> opt2 = 3;
 
       opt1.swap(opt2);
 
       opt1.value();
       /*[[check-1]]*/
 
       opt2.value();
       /*[[check-2]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check-1", "safe"),
-                           Pair("check-2", "unsafe: input.cc:13:7")));
+      "unsafe: input.cc:13:7");
 
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     void target() {
       $ns::$optional<int> opt1 = $ns::nullopt;
       $ns::$optional<int> opt2 = 3;
 
       opt2.swap(opt1);
 
       opt1.value();
       /*[[check-3]]*/
 
       opt2.value();
       /*[[check-4]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check-3", "safe"),
-                           Pair("check-4", "unsafe: input.cc:13:7")));
+      "unsafe: input.cc:13:7");
 }
 
 TEST_P(UncheckedOptionalAccessTest, StdSwap) {
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     void target() {
       $ns::$optional<int> opt1 = $ns::nullopt;
       $ns::$optional<int> opt2 = 3;
 
       std::swap(opt1, opt2);
 
       opt1.value();
       /*[[check-1]]*/
 
       opt2.value();
       /*[[check-2]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check-1", "safe"),
-                           Pair("check-2", "unsafe: input.cc:13:7")));
+      "unsafe: input.cc:13:7");
 
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     void target() {
       $ns::$optional<int> opt1 = $ns::nullopt;
       $ns::$optional<int> opt2 = 3;
 
       std::swap(opt2, opt1);
 
       opt1.value();
       /*[[check-3]]*/
 
       opt2.value();
       /*[[check-4]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check-3", "safe"),
-                           Pair("check-4", "unsafe: input.cc:13:7")));
+      "unsafe: input.cc:13:7");
 }
 
 TEST_P(UncheckedOptionalAccessTest, UniquePtrToStructWithOptionalField) {
   // We suppress diagnostics for values reachable from smart pointers (other
   // than `optional` itself).
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
ExpectLatticeChecksFor(
     void target() {
       smart_ptr<Foo> foo;
       *foo->opt;
       /*[[check-1]]*/
       *(*foo).opt;
       /*[[check-2]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check-1", "safe"), Pair("check-2", "safe")));
+      "safe");
 }
 
 TEST_P(UncheckedOptionalAccessTest, CallReturningOptional) {
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     $ns::$optional<int> MakeOpt();
 
     void target() {
       $ns::$optional<int> opt = 0;
       opt = MakeOpt();
       opt.value();
       /*[[check-1]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check-1", "unsafe: input.cc:9:7")));
+      "unsafe: input.cc:9:7");
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     const $ns::$optional<int>& MakeOpt();
 
     void target() {
       $ns::$optional<int> opt = 0;
       opt = MakeOpt();
       opt.value();
       /*[[check-2]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check-2", "unsafe: input.cc:9:7")));
+      "unsafe: input.cc:9:7");
 
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     using IntOpt = $ns::$optional<int>;
     IntOpt MakeOpt();
 
     void target() {
       IntOpt opt = 0;
       opt = MakeOpt();
       opt.value();
       /*[[check-3]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check-3", "unsafe: input.cc:10:7")));
+      "unsafe: input.cc:10:7");
 
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     using IntOpt = $ns::$optional<int>;
     const IntOpt& MakeOpt();
 
     void target() {
       IntOpt opt = 0;
       opt = MakeOpt();
       opt.value();
       /*[[check-4]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check-4", "unsafe: input.cc:10:7")));
+      "unsafe: input.cc:10:7");
 }
 
 // Verifies that the model sees through aliases.
 TEST_P(UncheckedOptionalAccessTest, WithAlias) {
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     template <typename T>
     using MyOptional = $ns::$optional<T>;
 
     void target(MyOptional<int> opt) {
       opt.value();
       /*[[check]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check", "unsafe: input.cc:8:7")));
+      "unsafe: input.cc:8:7");
 }
 
 TEST_P(UncheckedOptionalAccessTest, OptionalValueOptional) {
   // Basic test that nested values are populated.  We nest an optional because
   // its easy to use in a test, but the type of the nested value shouldn't
   // matter.
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     using Foo = $ns::$optional<std::string>;
 
     void target($ns::$optional<Foo> foo) {
       if (foo && *foo) {
         foo->value();
         /*[[access]]*/
       }
     }
   )",
-      UnorderedElementsAre(Pair("access", "safe")));
+      "safe");
 
   // Mutation is supported for nested values.
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     using Foo = $ns::$optional<std::string>;
 
     void target($ns::$optional<Foo> foo) {
       if (foo && *foo) {
         foo->reset();
         foo->value();
         /*[[reset]]*/
       }
     }
   )",
-      UnorderedElementsAre(Pair("reset", "unsafe: input.cc:9:9")));
+      "unsafe: input.cc:9:9");
 }
 
 // Tests that structs can be nested. We use an optional field because its easy
 // to use in a test, but the type of the field shouldn't matter.
 TEST_P(UncheckedOptionalAccessTest, OptionalValueStruct) {
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     struct Foo {
       $ns::$optional<std::string> opt;
     };
 
     void target($ns::$optional<Foo> foo) {
       if (foo && foo->opt) {
         foo->opt.value();
         /*[[access]]*/
       }
     }
   )",
-      UnorderedElementsAre(Pair("access", "safe")));
+      "safe");
 }
 
 TEST_P(UncheckedOptionalAccessTest, OptionalValueInitialization) {
   // FIXME: Fix when to initialize `value`. All unwrapping should be safe in
   // this example, but `value` initialization is done multiple times during the
   // fixpoint iterations and joining the environment won't correctly merge them.
   ExpectLatticeChecksFor(
       R"(
void target($ns::$optional<Foo> foo, bool b) {
         foo->value();
       }
       // Now we merge the two values. UncheckedOptionalAccessModel::merge() will
       // throw away the "value" property.
       foo->value();
       /*[[merge]]*/
     }
   )",
-      UnorderedElementsAre(Pair("merge", "unsafe: input.cc:19:7")));
+      "unsafe: input.cc:19:7");
 }
 
 TEST_P(UncheckedOptionalAccessTest, AssignThroughLvalueReferencePtr) {
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     template <typename T>
     struct smart_ptr {
       typename std::add_lvalue_reference<T>::type operator*() &;
     };
 
     void target() {
       smart_ptr<$ns::$optional<float>> x;
       *x = $ns::nullopt;
       (*x).value();
       /*[[check]]*/
     }
   )",
-      UnorderedElementsAre(Pair("check", "unsafe: input.cc:12:7")));
+      "unsafe: input.cc:12:7");
 }
 
 TEST_P(UncheckedOptionalAccessTest, CorrelatedBranches) {
   ExpectLatticeChecksFor(R"code(
     #include "unchecked_optional_access_test.h"
 
     void target(bool b, $ns::$optional<int> opt) {
       if (b || opt.has_value()) {
         if (!b) {
           opt.value();
           /*[[check-1]]*/
         }
       }
     }
   )code",
-                         UnorderedElementsAre(Pair("check-1", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(R"code(
     #include "unchecked_optional_access_test.h"
 
     void target(bool b, $ns::$optional<int> opt) {
       if (b && !opt.has_value()) return;
       if (b) {
         opt.value();
         /*[[check-2]]*/
       }
     }
   )code",
-                         UnorderedElementsAre(Pair("check-2", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(
       R"code(
     #include "unchecked_optional_access_test.h"
 
     void target(bool b, $ns::$optional<int> opt) {
       if (opt.has_value()) b = true;
       if (b) {
         opt.value();
         /*[[check-3]]*/
       }
     }
   )code",
-      UnorderedElementsAre(Pair("check-3", "unsafe: input.cc:7:9")));
+      "unsafe: input.cc:7:9");
 
   ExpectLatticeChecksFor(R"code(
     #include "unchecked_optional_access_test.h"
 
     void target(bool b, $ns::$optional<int> opt) {
       if (b) return;
       if (opt.has_value()) b = true;
       if (b) {
         opt.value();
         /*[[check-4]]*/
       }
     }
   )code",
-                         UnorderedElementsAre(Pair("check-4", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     void target(bool b, $ns::$optional<int> opt) {
       if (opt.has_value() == b) {
         if (b) {
           opt.value();
           /*[[check-5]]*/
         }
       }
     }
   )",
-                         UnorderedElementsAre(Pair("check-5", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     void target(bool b, $ns::$optional<int> opt) {
       if (opt.has_value() != b) {
         if (!b) {
           opt.value();
           /*[[check-6]]*/
         }
       }
     }
   )",
-                         UnorderedElementsAre(Pair("check-6", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     void target(bool b) {
       $ns::$optional<int> opt1 = $ns::nullopt;
       $ns::$optional<int> opt2;
       if (b) {
         opt2 = $ns::nullopt;
       } else {
         opt2 = $ns::nullopt;
       }
       if (opt2.has_value()) {
         opt1.value();
         /*[[check]]*/
       }
     }
   )",
-                         UnorderedElementsAre(Pair("check", "safe")));
+                         "safe");
 
   // FIXME: Add support for operator==.
   // ExpectLatticeChecksFor(R"(
   //   #include "unchecked_optional_access_test.h"
   //
   //   void target($ns::$optional<int> opt1, $ns::$optional<int> opt2) {
   //     if (opt1 == opt2) {
   //       if (opt1.has_value()) {
   //         opt2.value();
   //         /*[[check-7]]*/
   //       }
   //     }
   //   }
   // )",
-  //                     UnorderedElementsAre(Pair("check-7", "safe")));
+  //                     "safe");
 }
 
 TEST_P(UncheckedOptionalAccessTest, JoinDistinctValues) {
   ExpectLatticeChecksFor(
       R"code(
     #include "unchecked_optional_access_test.h"
 
     void target(bool b) {
       $ns::$optional<int> opt;
       if (b) {
         opt = Make<$ns::$optional<int>>();
       } else {
         opt = Make<$ns::$optional<int>>();
       }
       if (opt.has_value()) {
         opt.value();
         /*[[check-1]]*/
       } else {
         opt.value();
         /*[[check-2]]*/
       }
     }
   )code",
-      UnorderedElementsAre(Pair("check-1", "safe"),
-                           Pair("check-2", "unsafe: input.cc:15:9")));
+      "unsafe: input.cc:15:9");
 
   ExpectLatticeChecksFor(R"code(
     #include "unchecked_optional_access_test.h"
 
     void target(bool b) {
       $ns::$optional<int> opt;
       if (b) {
         opt = Make<$ns::$optional<int>>();
         if (!opt.has_value()) return;
       } else {
         opt = Make<$ns::$optional<int>>();
         if (!opt.has_value()) return;
       }
       opt.value();
       /*[[check-3]]*/
     }
   )code",
-                         UnorderedElementsAre(Pair("check-3", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(
       R"code(
     #include "unchecked_optional_access_test.h"
 
     void target(bool b) {
       $ns::$optional<int> opt;
       if (b) {
         opt = Make<$ns::$optional<int>>();
         if (!opt.has_value()) return;
       } else {
         opt = Make<$ns::$optional<int>>();
       }
       opt.value();
       /*[[check-4]]*/
     }
   )code",
-      UnorderedElementsAre(Pair("check-4", "unsafe: input.cc:12:7")));
+      "unsafe: input.cc:12:7");
 
   ExpectLatticeChecksFor(
       R"code(
     #include "unchecked_optional_access_test.h"
 
     void target(bool b) {
       $ns::$optional<int> opt;
       if (b) {
         opt = 1;
       } else {
         opt = 2;
       }
       opt.value();
       /*[[check-5]]*/
     }
   )code",
-      UnorderedElementsAre(Pair("check-5", "safe")));
+      "safe");
 
   ExpectLatticeChecksFor(
       R"code(
     #include "unchecked_optional_access_test.h"
 
     void target(bool b) {
       $ns::$optional<int> opt;
       if (b) {
         opt = 1;
       } else {
         opt = Make<$ns::$optional<int>>();
       }
       opt.value();
       /*[[check-6]]*/
     }
   )code",
-      UnorderedElementsAre(Pair("check-6", "unsafe: input.cc:11:7")));
+      "unsafe: input.cc:11:7");
 }
 
 TEST_P(UncheckedOptionalAccessTest, ReassignValueInLoop) {
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     void target() {
       $ns::$optional<int> opt = 3;
       while (Make<bool>()) {
         opt.value();
         /*[[check-1]]*/
       }
     }
   )",
-                         UnorderedElementsAre(Pair("check-1", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(R"(
     #include "unchecked_optional_access_test.h"
 
     void target() {
       $ns::$optional<int> opt = 3;
       while (Make<bool>()) {
         opt.value();
         /*[[check-2]]*/
 
         opt = Make<$ns::$optional<int>>();
         if (!opt.has_value()) return;
       }
     }
   )",
-                         UnorderedElementsAre(Pair("check-2", "safe")));
+                         "safe");
 
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     void target() {
       $ns::$optional<int> opt = 3;
       while (Make<bool>()) {
         opt.value();
         /*[[check-3]]*/
 
         opt = Make<$ns::$optional<int>>();
       }
     }
   )",
-      UnorderedElementsAre(Pair("check-3", "unsafe: input.cc:7:9")));
+      "unsafe: input.cc:7:9");
 
   ExpectLatticeChecksFor(
       R"(
     #include "unchecked_optional_access_test.h"
 
     void target() {
       $ns::$optional<int> opt = 3;
       while (Make<bool>()) {
         opt.value();
         /*[[check-4]]*/
 
         opt = Make<$ns::$optional<int>>();
         if (!opt.has_value()) continue;
       }
     }
   )",
-      UnorderedElementsAre(Pair("check-4", "unsafe: input.cc:7:9")));
+      "unsafe: input.cc:7:9");
 }
 
 // FIXME: Add support for:
 // - constructors (copy, move)
 // - assignment operators (default, copy, move)
 // - invalidation (passing optional by non-const reference/pointer)

llvm/utils/gn/secondary/clang/lib/Analysis/FlowSensitive/BUILD.gn

 static_library("FlowSensitive") {
   output_name = "clangAnalysisFlowSensitive"
   configs += [ "//llvm/utils/gn/build:clang_code" ]
   deps = [
     "//clang/lib/AST",
     "//clang/lib/Analysis",
   ]
   sources = [
     "ControlFlowContext.cpp",
     "DataflowAnalysisContext.cpp",
     "DataflowEnvironment.cpp",
-    "SourceLocationsLattice.cpp",
+    "SourceLocations.cpp",
     "Transfer.cpp",
     "TypeErasedDataflowAnalysis.cpp",
     "WatchedLiteralsSolver.cpp",
   ]
 }

llvm/utils/gn/secondary/clang/unittests/Analysis/FlowSensitive/BUILD.gn

sources = [
     "ChromiumCheckModelTest.cpp",
     "DataflowAnalysisContextTest.cpp",
     "DataflowEnvironmentTest.cpp",
     "MapLatticeTest.cpp",
     "MatchSwitchTest.cpp",
     "MultiVarConstantPropagationTest.cpp",
     "SingleVarConstantPropagationTest.cpp",
     "SolverTest.cpp",
-    "SourceLocationsLatticeTest.cpp",
     "TestingSupport.cpp",
     "TestingSupportTest.cpp",
     "TransferTest.cpp",
     "TypeErasedDataflowAnalysisTest.cpp",
     "UncheckedOptionalAccessModelTest.cpp",
   ]
 }