[clang] [clang][dataflow] Add a base dataflow model for `bugprone-unchecked-expected-access` [PR 1/N] (PR #242868)

Valentyn Yukhymenko via cfe-commits cfe-commits at lists.llvm.org
Sun Nov 15 13:18:00 PST 2026


https://github.com/BaLiKfromUA created https://github.com/llvm/llvm-project/pull/242868

This is the first part of a split of #233219 .

 It adds only the base dataflow model and its unit tests. 
 
  The clang-tidy check and the rest of the modeling will follow in separate PRs.

TODO: more details

>From 8625c5f542556db71124afe95d7d8a1102bebce7 Mon Sep 17 00:00:00 2001
From: BaLiKfromUA <valentin.yukhymenko at gmail.com>
Date: Sun, 15 Nov 2026 20:37:59 +0000
Subject: [PATCH 1/3] Implementation that passes simple optional-like tests

Add mock and basic tests to start with
---
 .../Models/UncheckedExpectedAccessModel.h     |  67 ++++
 .../FlowSensitive/Models/CMakeLists.txt       |   1 +
 .../Models/UncheckedExpectedAccessModel.cpp   | 160 ++++++++
 .../Analysis/FlowSensitive/CMakeLists.txt     |   1 +
 .../Analysis/FlowSensitive/MockHeaders.cpp    | 120 ++++++
 .../UncheckedExpectedAccessModelTest.cpp      | 341 ++++++++++++++++++
 6 files changed, 690 insertions(+)
 create mode 100644 clang/include/clang/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.h
 create mode 100644 clang/lib/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.cpp
 create mode 100644 clang/unittests/Analysis/FlowSensitive/UncheckedExpectedAccessModelTest.cpp

diff --git a/clang/include/clang/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.h b/clang/include/clang/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.h
new file mode 100644
index 00000000000000..1e9390ee190c3e
--- /dev/null
+++ b/clang/include/clang/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.h
@@ -0,0 +1,67 @@
+//===-- UncheckedExpectedAccessModel.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 dataflow analysis that detects unsafe accesses to the
+//  values of `std::expected` objects.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef CLANG_ANALYSIS_FLOWSENSITIVE_MODELS_UNCHECKEDEXPECTEDACCESSMODEL_H
+#define CLANG_ANALYSIS_FLOWSENSITIVE_MODELS_UNCHECKEDEXPECTEDACCESSMODEL_H
+
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/Analysis/CFG.h"
+#include "clang/Analysis/FlowSensitive/CFGMatchSwitch.h"
+#include "clang/Analysis/FlowSensitive/DataflowAnalysis.h"
+#include "clang/Analysis/FlowSensitive/DataflowEnvironment.h"
+#include "clang/Analysis/FlowSensitive/NoopLattice.h"
+#include "clang/Basic/SourceLocation.h"
+#include "llvm/ADT/SmallVector.h"
+
+namespace clang {
+namespace dataflow {
+
+/// Dataflow analysis that models whether `std::expected` objects hold values.
+class UncheckedExpectedAccessModel
+    : public DataflowAnalysis<UncheckedExpectedAccessModel, NoopLattice> {
+public:
+  UncheckedExpectedAccessModel(ASTContext &Ctx, Environment &Env);
+
+  /// Returns a matcher for calls to member functions of `std::expected`.
+  static ast_matchers::StatementMatcher callToExpectedClass();
+
+  static NoopLattice initialElement() { return {}; }
+
+  void transfer(const CFGElement &Elt, NoopLattice &L, Environment &Env);
+
+private:
+  CFGMatchSwitch<TransferState<NoopLattice>> TransferMatchSwitch;
+};
+
+/// Reports the locations of accesses to `std::expected` values that are not
+/// provably preceded by a check that the object holds a value.
+class UncheckedExpectedAccessDiagnoser {
+public:
+  UncheckedExpectedAccessDiagnoser();
+
+  llvm::SmallVector<SourceLocation>
+  operator()(const CFGElement &Elt, ASTContext &Ctx,
+             const TransferStateForDiagnostics<NoopLattice> &State) {
+    return DiagnoseMatchSwitch(Elt, Ctx, State.Env);
+  }
+
+private:
+  CFGMatchSwitch<const Environment, llvm::SmallVector<SourceLocation>>
+      DiagnoseMatchSwitch;
+};
+
+} // namespace dataflow
+} // namespace clang
+
+#endif // CLANG_ANALYSIS_FLOWSENSITIVE_MODELS_UNCHECKEDEXPECTEDACCESSMODEL_H
diff --git a/clang/lib/Analysis/FlowSensitive/Models/CMakeLists.txt b/clang/lib/Analysis/FlowSensitive/Models/CMakeLists.txt
index 62c9473842779d..41ab2c6fa786c5 100644
--- a/clang/lib/Analysis/FlowSensitive/Models/CMakeLists.txt
+++ b/clang/lib/Analysis/FlowSensitive/Models/CMakeLists.txt
@@ -1,5 +1,6 @@
 add_clang_library(clangAnalysisFlowSensitiveModels
   ChromiumCheckModel.cpp
+  UncheckedExpectedAccessModel.cpp
   UncheckedOptionalAccessModel.cpp
   UncheckedStatusOrAccessModel.cpp
   GtestModelHelpers.cpp
diff --git a/clang/lib/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.cpp b/clang/lib/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.cpp
new file mode 100644
index 00000000000000..9bbb2f6e5b394d
--- /dev/null
+++ b/clang/lib/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.cpp
@@ -0,0 +1,160 @@
+//===-- UncheckedExpectedAccessModel.cpp ------------------------*- 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 dataflow analysis that detects unsafe accesses to the
+//  values of `std::expected` objects.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.h"
+#include "clang/AST/DeclCXX.h"
+#include "clang/AST/ExprCXX.h"
+#include "clang/ASTMatchers/ASTMatchersMacros.h"
+#include "clang/Analysis/FlowSensitive/StorageLocation.h"
+#include "clang/Analysis/FlowSensitive/Value.h"
+
+namespace clang {
+namespace dataflow {
+
+static bool isExpectedClass(const CXXRecordDecl &RD) {
+  return RD.getDeclName().isIdentifier() && RD.getName() == "expected" &&
+         RD.getDeclContext()->isStdNamespace();
+}
+
+// Classes derived from `std::expected` are deliberately not supported.
+static bool isExpectedType(QualType Ty) {
+  const CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
+  return RD != nullptr && isExpectedClass(*RD);
+}
+
+namespace {
+
+using namespace ::clang::ast_matchers;
+
+using LatticeTransferState = TransferState<NoopLattice>;
+
+AST_MATCHER(CXXRecordDecl, expectedClass) { return isExpectedClass(Node); }
+
+auto expectedMemberCall(ast_matchers::internal::Matcher<NamedDecl> Name) {
+  return cxxMemberCallExpr(
+      callee(cxxMethodDecl(Name, ofClass(expectedClass()))));
+}
+
+auto expectedOperatorCall(ArrayRef<StringRef> Names) {
+  return cxxOperatorCallExpr(hasAnyOverloadedOperatorName(Names),
+                             callee(cxxMethodDecl(ofClass(expectedClass()))));
+}
+
+StorageLocation &locForHasValue(const RecordStorageLocation &ExpectedLoc) {
+  return ExpectedLoc.getSyntheticField("has_value");
+}
+
+/// Returns the symbolic value that represents the "has_value" property of the
+/// expected at `ExpectedLoc`. Returns null if `ExpectedLoc` is null or is not
+/// the location of a `std::expected` object (e.g. of a derived class object).
+BoolValue *getHasValue(Environment &Env, RecordStorageLocation *ExpectedLoc) {
+  if (ExpectedLoc == nullptr || !isExpectedType(ExpectedLoc->getType()))
+    return nullptr;
+  StorageLocation &HasValueLoc = locForHasValue(*ExpectedLoc);
+  auto *HasValueVal = Env.get<BoolValue>(HasValueLoc);
+  if (HasValueVal == nullptr) {
+    HasValueVal = &Env.makeAtomicBoolValue();
+    Env.setValue(HasValueLoc, *HasValueVal);
+  }
+  return HasValueVal;
+}
+
+void transferHasValueCall(const CXXMemberCallExpr *E,
+                          const MatchFinder::MatchResult &,
+                          LatticeTransferState &State) {
+  if (BoolValue *HasValueVal =
+          getHasValue(State.Env, getImplicitObjectLocation(*E, State.Env)))
+    State.Env.setValue(*E, *HasValueVal);
+}
+
+// FIXME: Model the constructors, assignments, `emplace` and `swap`.
+auto buildTransferMatchSwitch() {
+  return CFGMatchSwitchBuilder<LatticeTransferState>()
+      // expected::has_value, expected::operator bool
+      .CaseOfCFGStmt<CXXMemberCallExpr>(
+          expectedMemberCall(hasAnyName("has_value", "operator bool")),
+          transferHasValueCall)
+      .Build();
+}
+
+llvm::SmallVector<SourceLocation>
+diagnoseAccess(SourceLocation AccessLoc,
+               const RecordStorageLocation *ExpectedLoc,
+               const Environment &Env) {
+  if (ExpectedLoc != nullptr) {
+    // Accesses through classes derived from `std::expected` are not modeled.
+    if (!isExpectedType(ExpectedLoc->getType()))
+      return {};
+    if (auto *HasValueVal = Env.get<BoolValue>(locForHasValue(*ExpectedLoc)))
+      if (Env.proves(HasValueVal->formula()))
+        return {};
+  }
+
+  return {AccessLoc};
+}
+
+auto buildDiagnoseMatchSwitch() {
+  return CFGMatchSwitchBuilder<const Environment,
+                               llvm::SmallVector<SourceLocation>>()
+      // expected::value
+      .CaseOfCFGStmt<CXXMemberCallExpr>(
+          expectedMemberCall(hasName("value")),
+          [](const CXXMemberCallExpr *E, const MatchFinder::MatchResult &,
+             const Environment &Env) {
+            return diagnoseAccess(E->getExprLoc(),
+                                  getImplicitObjectLocation(*E, Env), Env);
+          })
+      // expected::operator*, expected::operator->
+      .CaseOfCFGStmt<CXXOperatorCallExpr>(
+          expectedOperatorCall({"*", "->"}),
+          [](const CXXOperatorCallExpr *E, const MatchFinder::MatchResult &,
+             const Environment &Env) {
+            // `getExprLoc` of `operator->` is the start of the object
+            // expression, so point at the operator token instead.
+            return diagnoseAccess(E->getOperatorLoc(),
+                                  Env.get<RecordStorageLocation>(*E->getArg(0)),
+                                  Env);
+          })
+      .Build();
+}
+
+} // namespace
+
+ast_matchers::StatementMatcher
+UncheckedExpectedAccessModel::callToExpectedClass() {
+  return callExpr(callee(cxxMethodDecl(ofClass(expectedClass()))));
+}
+
+UncheckedExpectedAccessModel::UncheckedExpectedAccessModel(ASTContext &Ctx,
+                                                           Environment &Env)
+    : DataflowAnalysis<UncheckedExpectedAccessModel, NoopLattice>(Ctx),
+      TransferMatchSwitch(buildTransferMatchSwitch()) {
+  Env.getDataflowAnalysisContext().setSyntheticFieldCallback(
+      [&Ctx](QualType Ty) -> llvm::StringMap<QualType> {
+        if (!isExpectedType(Ty))
+          return {};
+        return {{"has_value", Ctx.BoolTy}};
+      });
+}
+
+void UncheckedExpectedAccessModel::transfer(const CFGElement &Elt,
+                                            NoopLattice &L, Environment &Env) {
+  LatticeTransferState State(L, Env);
+  TransferMatchSwitch(Elt, getASTContext(), State);
+}
+
+UncheckedExpectedAccessDiagnoser::UncheckedExpectedAccessDiagnoser()
+    : DiagnoseMatchSwitch(buildDiagnoseMatchSwitch()) {}
+
+} // namespace dataflow
+} // namespace clang
diff --git a/clang/unittests/Analysis/FlowSensitive/CMakeLists.txt b/clang/unittests/Analysis/FlowSensitive/CMakeLists.txt
index 1d932ec6e8a963..8dae4d0c3282b2 100644
--- a/clang/unittests/Analysis/FlowSensitive/CMakeLists.txt
+++ b/clang/unittests/Analysis/FlowSensitive/CMakeLists.txt
@@ -24,6 +24,7 @@ add_clang_unittest(ClangAnalysisFlowSensitiveTests
   TransferBranchTest.cpp
   TransferTest.cpp
   TypeErasedDataflowAnalysisTest.cpp
+  UncheckedExpectedAccessModelTest.cpp
   UncheckedOptionalAccessModelTest.cpp
   UncheckedStatusOrAccessModelTest.cpp
   UncheckedStatusOrAccessModelTestFixture.cpp
diff --git a/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp b/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp
index 3601d3efbcf1bf..68b58169cbdf75 100644
--- a/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp
+++ b/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp
@@ -820,6 +820,125 @@ constexpr bool operator!=(const T &value, const optional<U> &opt);
 } // namespace std
 )";
 
+static constexpr char StdExpectedHeader[] = R"(
+#ifndef STD_EXPECTED_H
+#define STD_EXPECTED_H
+
+namespace std {
+
+template <class E> class unexpected {
+public:
+  unexpected(const unexpected &) = default;
+  unexpected(unexpected &&) = default;
+
+  template <class Err = E> explicit unexpected(Err &&e);
+
+  const E &error() const & noexcept;
+  E &error() & noexcept;
+  const E &&error() const && noexcept;
+  E &&error() && noexcept;
+};
+
+template <class E> unexpected(E) -> unexpected<E>;
+
+struct unexpect_t {
+  explicit unexpect_t() = default;
+};
+
+inline constexpr unexpect_t unexpect{};
+
+template <class T, class E> class expected {
+public:
+  using value_type = T;
+  using error_type = E;
+  using unexpected_type = unexpected<E>;
+
+  expected();
+  expected(const expected &);
+  expected(expected &&) noexcept;
+
+  template <class U = T> expected(U &&v);
+
+  template <class G> expected(const unexpected<G> &e);
+  template <class G> expected(unexpected<G> &&e);
+
+  template <class... Args>
+  explicit expected(unexpect_t, Args &&...args);
+
+  expected &operator=(const expected &);
+  expected &operator=(expected &&) noexcept;
+
+  const T *operator->() const noexcept;
+  T *operator->() noexcept;
+
+  const T &operator*() const & noexcept;
+  T &operator*() & noexcept;
+  const T &&operator*() const && noexcept;
+  T &&operator*() && noexcept;
+
+  explicit operator bool() const noexcept;
+  bool has_value() const noexcept;
+
+  const T &value() const &;
+  T &value() &;
+  const T &&value() const &&;
+  T &&value() &&;
+
+  const E &error() const & noexcept;
+  E &error() & noexcept;
+  const E &&error() const && noexcept;
+  E &&error() && noexcept;
+
+  template <class U> T value_or(U &&v) const &;
+  template <class U> T value_or(U &&v) &&;
+
+  template <class... Args> T &emplace(Args &&...args) noexcept;
+
+  void swap(expected &rhs) noexcept;
+};
+
+template <class E> class expected<void, E> {
+public:
+  using value_type = void;
+  using error_type = E;
+  using unexpected_type = unexpected<E>;
+
+  expected() noexcept;
+  expected(const expected &);
+  expected(expected &&) noexcept;
+
+  template <class G> expected(const unexpected<G> &e);
+  template <class G> expected(unexpected<G> &&e);
+
+  template <class... Args>
+  explicit expected(unexpect_t, Args &&...args);
+
+  expected &operator=(const expected &);
+  expected &operator=(expected &&) noexcept;
+
+  explicit operator bool() const noexcept;
+  bool has_value() const noexcept;
+
+  void operator*() const noexcept;
+
+  void value() const &;
+  void value() &&;
+
+  const E &error() const & noexcept;
+  E &error() & noexcept;
+  const E &&error() const && noexcept;
+  E &&error() && noexcept;
+
+  void emplace() noexcept;
+
+  void swap(expected &rhs) noexcept;
+};
+
+} // namespace std
+
+#endif // STD_EXPECTED_H
+)";
+
 static constexpr char AbslOptionalHeader[] = R"(
 #include "absl_type_traits.h"
 #include "std_initializer_list.h"
@@ -2503,6 +2622,7 @@ std::vector<std::pair<std::string, std::string>> getMockHeaders() {
   Headers.emplace_back("std_type_traits.h", StdTypeTraitsHeader);
   Headers.emplace_back("std_utility.h", StdUtilityHeader);
   Headers.emplace_back("std_optional.h", StdOptionalHeader);
+  Headers.emplace_back("std_expected.h", StdExpectedHeader);
   Headers.emplace_back("std_coroutine.h", StdCoroutineHeader);
   Headers.emplace_back("absl_type_traits.h", AbslTypeTraitsHeader);
   Headers.emplace_back("absl_optional.h", AbslOptionalHeader);
diff --git a/clang/unittests/Analysis/FlowSensitive/UncheckedExpectedAccessModelTest.cpp b/clang/unittests/Analysis/FlowSensitive/UncheckedExpectedAccessModelTest.cpp
new file mode 100644
index 00000000000000..1abd1d4edbb519
--- /dev/null
+++ b/clang/unittests/Analysis/FlowSensitive/UncheckedExpectedAccessModelTest.cpp
@@ -0,0 +1,341 @@
+//===- UncheckedExpectedAccessModelTest.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/Models/UncheckedExpectedAccessModel.h"
+#include "MockHeaders.h"
+#include "TestingSupport.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Frontend/TextDiagnostic.h"
+#include "clang/Tooling/Tooling.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/STLExtras.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::ContainerEq;
+
+/// 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);
+    if (Pos == std::string::npos)
+      break;
+    S.replace(Pos, Pattern.size(), Replacement);
+  }
+}
+
+struct ExpectedTypeIdentifier {
+  std::string NamespaceName;
+};
+
+static raw_ostream &operator<<(raw_ostream &OS,
+                               const ExpectedTypeIdentifier &TypeId) {
+  OS << TypeId.NamespaceName << "::expected";
+  return OS;
+}
+
+class UncheckedExpectedAccessTest
+    : public ::testing::TestWithParam<ExpectedTypeIdentifier> {
+protected:
+  // Check that after running the analysis on SourceCode, it produces the
+  // expected diagnostics according to [[unsafe]] annotations.
+  // - No annotations => no diagnostics.
+  // - Given "// [[unsafe]]" annotations on a line, we expect a diagnostic on
+  //   that line.
+  void ExpectDiagnosticsFor(std::string SourceCode) {
+    // Run in C++17 and C++20 mode to cover differences in the AST between modes
+    // (e.g. C++20 can contain `CXXRewrittenBinaryOperator`).
+    for (const char *CxxMode : {"-std=c++17", "-std=c++20"})
+      ExpectDiagnosticsFor(SourceCode, CxxMode);
+  }
+
+  void ExpectDiagnosticsFor(std::string SourceCode, const char *CxxMode) {
+    ReplaceAllOccurrences(SourceCode, "$ns", GetParam().NamespaceName);
+
+    auto Headers = getMockHeaders();
+    Headers.emplace_back("unchecked_expected_access_test.h", R"(
+      #include "std_expected.h"
+      #include "std_utility.h"
+
+      template <typename T>
+      T Make();
+    )");
+    std::vector<SourceLocation> Diagnostics;
+    llvm::Error Error = checkDataflow<UncheckedExpectedAccessModel>(
+        AnalysisInputs<UncheckedExpectedAccessModel>(
+            SourceCode, ast_matchers::hasName("target"),
+            [](ASTContext &Ctx, Environment &Env) {
+              return UncheckedExpectedAccessModel(Ctx, Env);
+            })
+            .withDiagnosisCallbacks(
+                {/*Before=*/[&Diagnostics,
+                             Diagnoser = UncheckedExpectedAccessDiagnoser()](
+                                ASTContext &Ctx, const CFGElement &Elt,
+                                const TransferStateForDiagnostics<NoopLattice>
+                                    &State) mutable {
+                   auto EltDiagnostics = Diagnoser(Elt, Ctx, State);
+                   llvm::move(EltDiagnostics, std::back_inserter(Diagnostics));
+                 },
+                 /*After=*/nullptr})
+            .withASTBuildArgs(
+                {"-fsyntax-only", CxxMode, "-Wno-undefined-inline"})
+            .withASTBuildVirtualMappedFiles(
+                tooling::FileContentMappings(Headers.begin(), Headers.end())),
+        /*VerifyResults=*/[&Diagnostics](
+                              const llvm::DenseMap<unsigned, std::string>
+                                  &Annotations,
+                              const AnalysisOutputs &AO) {
+          llvm::DenseSet<unsigned> AnnotationLines;
+          for (const auto &[Line, _] : Annotations)
+            AnnotationLines.insert(Line);
+          auto &SrcMgr = AO.ASTCtx.getSourceManager();
+          llvm::DenseSet<unsigned> DiagnosticLines;
+          for (SourceLocation Loc : Diagnostics) {
+            unsigned Line = SrcMgr.getPresumedLineNumber(Loc);
+            DiagnosticLines.insert(Line);
+            if (!AnnotationLines.contains(Line)) {
+              DiagnosticOptions DiagOpts;
+              TextDiagnostic TD(llvm::errs(), AO.ASTCtx.getLangOpts(),
+                                DiagOpts);
+              TD.emitDiagnostic(FullSourceLoc(Loc, SrcMgr),
+                                DiagnosticsEngine::Error,
+                                "unexpected diagnostic", {}, {});
+            }
+          }
+
+          EXPECT_THAT(DiagnosticLines, ContainerEq(AnnotationLines));
+        });
+    if (Error)
+      FAIL() << llvm::toString(std::move(Error));
+  }
+};
+
+INSTANTIATE_TEST_SUITE_P(
+    UncheckedExpectedUseTestInst, UncheckedExpectedAccessTest,
+    ::testing::Values(ExpectedTypeIdentifier{"std"}),
+    [](const ::testing::TestParamInfo<ExpectedTypeIdentifier> &Info) {
+      return Info.param.NamespaceName;
+    });
+
+TEST_P(UncheckedExpectedAccessTest, EmptyFunctionBody) {
+  ExpectDiagnosticsFor(R"(
+    void target() {
+      (void)0;
+    }
+  )");
+}
+
+TEST_P(UncheckedExpectedAccessTest, UnwrapUsingValueNoCheck) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target($ns::expected<int, int> e) {
+      e.value(); // [[unsafe]]
+    }
+  )");
+
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target(const $ns::expected<int, int> &e) {
+      e.value(); // [[unsafe]]
+    }
+  )");
+}
+
+TEST_P(UncheckedExpectedAccessTest, UnwrapUsingOperatorStarNoCheck) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target($ns::expected<int, int> e) {
+      *e; // [[unsafe]]
+    }
+  )");
+
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target(const $ns::expected<int, int> &e) {
+      *e; // [[unsafe]]
+    }
+  )");
+}
+
+TEST_P(UncheckedExpectedAccessTest, UnwrapUsingOperatorArrowNoCheck) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    struct Foo {
+      void foo() const {}
+    };
+
+    void target($ns::expected<Foo, int> e) {
+      e->foo(); // [[unsafe]]
+    }
+  )");
+
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    struct Foo {
+      void foo() const {}
+    };
+
+    void target(const $ns::expected<Foo, int> &e) {
+      e->foo(); // [[unsafe]]
+    }
+  )");
+}
+
+TEST_P(UncheckedExpectedAccessTest, UnwrapFunctionCallResultNoCheck) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target() {
+      auto e = Make<$ns::expected<int, int>>();
+      e.value(); // [[unsafe]]
+    }
+  )");
+}
+
+TEST_P(UncheckedExpectedAccessTest, UnwrapVoidUsingValueNoCheck) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target($ns::expected<void, int> e) {
+      e.value(); // [[unsafe]]
+    }
+  )");
+}
+
+TEST_P(UncheckedExpectedAccessTest, UnwrapInElseBranch) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target($ns::expected<int, int> e) {
+      if (e.has_value()) {
+      } else {
+        e.value(); // [[unsafe]]
+      }
+    }
+  )");
+}
+
+TEST_P(UncheckedExpectedAccessTest, UnwrapInNegatedCheck) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target($ns::expected<int, int> e) {
+      if (!e) {
+        *e; // [[unsafe]]
+      }
+    }
+  )");
+
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    int target($ns::expected<int, int> e) {
+      return !e ? *e : 0; // [[unsafe]]
+    }
+  )");
+}
+
+TEST_P(UncheckedExpectedAccessTest, HasValueCheck) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    struct Foo {
+      void foo() const {}
+    };
+
+    void target($ns::expected<Foo, int> e) {
+      if (e.has_value()) {
+        e.value();
+        *e;
+        e->foo();
+      }
+    }
+  )");
+}
+
+TEST_P(UncheckedExpectedAccessTest, OperatorBoolCheck) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target($ns::expected<int, int> e) {
+      if (e) {
+        e.value();
+        *e;
+      }
+    }
+  )");
+}
+
+TEST_P(UncheckedExpectedAccessTest, CheckedAfterEarlyReturn) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target($ns::expected<int, int> e) {
+      if (!e)
+        return;
+      e.value();
+    }
+  )");
+
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    int target($ns::expected<int, int> e) {
+      if (!e.has_value())
+        return 0;
+      return *e;
+    }
+  )");
+}
+
+TEST_P(UncheckedExpectedAccessTest, CheckedInTernary) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    int target($ns::expected<int, int> e) {
+      return e ? *e : 0;
+    }
+  )");
+
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    int target($ns::expected<int, int> e) {
+      return e.has_value() ? e.value() : 0;
+    }
+  )");
+}
+
+TEST_P(UncheckedExpectedAccessTest, ValueOrIsNotAnAccess) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target($ns::expected<int, int> e) {
+      e.value_or(0);
+    }
+  )");
+}

>From 3e1355d974b3b2ce2c9ef0a96a24fbea14c1f2b9 Mon Sep 17 00:00:00 2001
From: BaLiKfromUA <valentin.yukhymenko at gmail.com>
Date: Sun, 15 Nov 2026 20:38:54 +0000
Subject: [PATCH 2/3] Add basic of `.error()`

Add basic tests for `.error()` access
---
 .../Models/UncheckedExpectedAccessModel.h     |  26 ++-
 .../Models/UncheckedExpectedAccessModel.cpp   |  39 +++-
 .../Analysis/FlowSensitive/MockHeaders.cpp    |   6 +
 .../UncheckedExpectedAccessModelTest.cpp      | 201 +++++++++++++++++-
 4 files changed, 251 insertions(+), 21 deletions(-)

diff --git a/clang/include/clang/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.h b/clang/include/clang/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.h
index 1e9390ee190c3e..b6d6b0e5e118a6 100644
--- a/clang/include/clang/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.h
+++ b/clang/include/clang/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.h
@@ -44,20 +44,38 @@ class UncheckedExpectedAccessModel
   CFGMatchSwitch<TransferState<NoopLattice>> TransferMatchSwitch;
 };
 
-/// Reports the locations of accesses to `std::expected` values that are not
-/// provably preceded by a check that the object holds a value.
+/// The part of a `std::expected` object that is accessed.
+///
+/// The values are used as `%select` indices in diagnostics, so they must not
+/// be reordered.
+enum class UncheckedExpectedAccessKind : int {
+  /// `value()`, `operator*` or `operator->`, which require a value.
+  Value = 0,
+  /// `error()`, which requires an error.
+  Error = 1,
+};
+
+/// Diagnostic information for an unchecked `std::expected` access.
+struct UncheckedExpectedAccessDiagnostic {
+  SourceLocation Loc;
+  UncheckedExpectedAccessKind Kind;
+};
+
+/// Reports accesses to the value (or error) of `std::expected` objects that are
+/// not provably preceded by a check that the object holds a value (or error).
 class UncheckedExpectedAccessDiagnoser {
 public:
   UncheckedExpectedAccessDiagnoser();
 
-  llvm::SmallVector<SourceLocation>
+  llvm::SmallVector<UncheckedExpectedAccessDiagnostic>
   operator()(const CFGElement &Elt, ASTContext &Ctx,
              const TransferStateForDiagnostics<NoopLattice> &State) {
     return DiagnoseMatchSwitch(Elt, Ctx, State.Env);
   }
 
 private:
-  CFGMatchSwitch<const Environment, llvm::SmallVector<SourceLocation>>
+  CFGMatchSwitch<const Environment,
+                 llvm::SmallVector<UncheckedExpectedAccessDiagnostic>>
       DiagnoseMatchSwitch;
 };
 
diff --git a/clang/lib/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.cpp b/clang/lib/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.cpp
index 9bbb2f6e5b394d..f9376bafd98d0b 100644
--- a/clang/lib/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.cpp
+++ b/clang/lib/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.cpp
@@ -15,6 +15,8 @@
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/ASTMatchers/ASTMatchersMacros.h"
+#include "clang/Analysis/FlowSensitive/Arena.h"
+#include "clang/Analysis/FlowSensitive/Formula.h"
 #include "clang/Analysis/FlowSensitive/StorageLocation.h"
 #include "clang/Analysis/FlowSensitive/Value.h"
 
@@ -87,31 +89,39 @@ auto buildTransferMatchSwitch() {
       .Build();
 }
 
-llvm::SmallVector<SourceLocation>
-diagnoseAccess(SourceLocation AccessLoc,
+llvm::SmallVector<UncheckedExpectedAccessDiagnostic>
+diagnoseAccess(SourceLocation AccessLoc, UncheckedExpectedAccessKind Kind,
                const RecordStorageLocation *ExpectedLoc,
                const Environment &Env) {
   if (ExpectedLoc != nullptr) {
     // Accesses through classes derived from `std::expected` are not modeled.
     if (!isExpectedType(ExpectedLoc->getType()))
       return {};
-    if (auto *HasValueVal = Env.get<BoolValue>(locForHasValue(*ExpectedLoc)))
-      if (Env.proves(HasValueVal->formula()))
+    if (auto *HasValueVal = Env.get<BoolValue>(locForHasValue(*ExpectedLoc))) {
+      // The value may only be accessed if the expected holds a value, and the
+      // error only if it does not.
+      const Formula &Safe = Kind == UncheckedExpectedAccessKind::Value
+                                ? HasValueVal->formula()
+                                : Env.arena().makeNot(HasValueVal->formula());
+      if (Env.proves(Safe))
         return {};
+    }
   }
 
-  return {AccessLoc};
+  return {{AccessLoc, Kind}};
 }
 
 auto buildDiagnoseMatchSwitch() {
-  return CFGMatchSwitchBuilder<const Environment,
-                               llvm::SmallVector<SourceLocation>>()
+  return CFGMatchSwitchBuilder<
+             const Environment,
+             llvm::SmallVector<UncheckedExpectedAccessDiagnostic>>()
       // expected::value
       .CaseOfCFGStmt<CXXMemberCallExpr>(
           expectedMemberCall(hasName("value")),
           [](const CXXMemberCallExpr *E, const MatchFinder::MatchResult &,
              const Environment &Env) {
             return diagnoseAccess(E->getExprLoc(),
+                                  UncheckedExpectedAccessKind::Value,
                                   getImplicitObjectLocation(*E, Env), Env);
           })
       // expected::operator*, expected::operator->
@@ -121,9 +131,18 @@ auto buildDiagnoseMatchSwitch() {
              const Environment &Env) {
             // `getExprLoc` of `operator->` is the start of the object
             // expression, so point at the operator token instead.
-            return diagnoseAccess(E->getOperatorLoc(),
-                                  Env.get<RecordStorageLocation>(*E->getArg(0)),
-                                  Env);
+            return diagnoseAccess(
+                E->getOperatorLoc(), UncheckedExpectedAccessKind::Value,
+                Env.get<RecordStorageLocation>(*E->getArg(0)), Env);
+          })
+      // expected::error
+      .CaseOfCFGStmt<CXXMemberCallExpr>(
+          expectedMemberCall(hasName("error")),
+          [](const CXXMemberCallExpr *E, const MatchFinder::MatchResult &,
+             const Environment &Env) {
+            return diagnoseAccess(E->getExprLoc(),
+                                  UncheckedExpectedAccessKind::Error,
+                                  getImplicitObjectLocation(*E, Env), Env);
           })
       .Build();
 }
diff --git a/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp b/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp
index 68b58169cbdf75..97d77d3dbcac23 100644
--- a/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp
+++ b/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp
@@ -892,6 +892,9 @@ template <class T, class E> class expected {
   template <class U> T value_or(U &&v) const &;
   template <class U> T value_or(U &&v) &&;
 
+  template <class G> E error_or(G &&e) const &;
+  template <class G> E error_or(G &&e) &&;
+
   template <class... Args> T &emplace(Args &&...args) noexcept;
 
   void swap(expected &rhs) noexcept;
@@ -929,6 +932,9 @@ template <class E> class expected<void, E> {
   const E &&error() const && noexcept;
   E &&error() && noexcept;
 
+  template <class G> E error_or(G &&e) const &;
+  template <class G> E error_or(G &&e) &&;
+
   void emplace() noexcept;
 
   void swap(expected &rhs) noexcept;
diff --git a/clang/unittests/Analysis/FlowSensitive/UncheckedExpectedAccessModelTest.cpp b/clang/unittests/Analysis/FlowSensitive/UncheckedExpectedAccessModelTest.cpp
index 1abd1d4edbb519..409f0e918731ed 100644
--- a/clang/unittests/Analysis/FlowSensitive/UncheckedExpectedAccessModelTest.cpp
+++ b/clang/unittests/Analysis/FlowSensitive/UncheckedExpectedAccessModelTest.cpp
@@ -58,8 +58,10 @@ class UncheckedExpectedAccessTest
   // Check that after running the analysis on SourceCode, it produces the
   // expected diagnostics according to [[unsafe]] annotations.
   // - No annotations => no diagnostics.
-  // - Given "// [[unsafe]]" annotations on a line, we expect a diagnostic on
-  //   that line.
+  // - Given "// [[unsafe]]" annotations on a line, we expect a diagnostic for
+  //   an unchecked value access on that line.
+  // - Given "// [[unsafe:error]]" annotations on a line, we expect a diagnostic
+  //   for an unchecked error access on that line.
   void ExpectDiagnosticsFor(std::string SourceCode) {
     // Run in C++17 and C++20 mode to cover differences in the AST between modes
     // (e.g. C++20 can contain `CXXRewrittenBinaryOperator`).
@@ -78,7 +80,7 @@ class UncheckedExpectedAccessTest
       template <typename T>
       T Make();
     )");
-    std::vector<SourceLocation> Diagnostics;
+    std::vector<UncheckedExpectedAccessDiagnostic> Diagnostics;
     llvm::Error Error = checkDataflow<UncheckedExpectedAccessModel>(
         AnalysisInputs<UncheckedExpectedAccessModel>(
             SourceCode, ast_matchers::hasName("target"),
@@ -108,16 +110,23 @@ class UncheckedExpectedAccessTest
             AnnotationLines.insert(Line);
           auto &SrcMgr = AO.ASTCtx.getSourceManager();
           llvm::DenseSet<unsigned> DiagnosticLines;
-          for (SourceLocation Loc : Diagnostics) {
-            unsigned Line = SrcMgr.getPresumedLineNumber(Loc);
+          for (const UncheckedExpectedAccessDiagnostic &Diag : Diagnostics) {
+            unsigned Line = SrcMgr.getPresumedLineNumber(Diag.Loc);
             DiagnosticLines.insert(Line);
-            if (!AnnotationLines.contains(Line)) {
+            auto It = Annotations.find(Line);
+            if (It == Annotations.end()) {
               DiagnosticOptions DiagOpts;
               TextDiagnostic TD(llvm::errs(), AO.ASTCtx.getLangOpts(),
                                 DiagOpts);
-              TD.emitDiagnostic(FullSourceLoc(Loc, SrcMgr),
+              TD.emitDiagnostic(FullSourceLoc(Diag.Loc, SrcMgr),
                                 DiagnosticsEngine::Error,
                                 "unexpected diagnostic", {}, {});
+            } else {
+              UncheckedExpectedAccessKind ExpectedKind =
+                  It->second == "unsafe:error"
+                      ? UncheckedExpectedAccessKind::Error
+                      : UncheckedExpectedAccessKind::Value;
+              EXPECT_EQ(Diag.Kind, ExpectedKind) << "on line " << Line;
             }
           }
 
@@ -339,3 +348,181 @@ TEST_P(UncheckedExpectedAccessTest, ValueOrIsNotAnAccess) {
     }
   )");
 }
+
+TEST_P(UncheckedExpectedAccessTest, UnwrapErrorNoCheck) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target($ns::expected<int, int> e) {
+      e.error(); // [[unsafe:error]]
+    }
+  )");
+
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target(const $ns::expected<int, int> &e) {
+      e.error(); // [[unsafe:error]]
+    }
+  )");
+}
+
+TEST_P(UncheckedExpectedAccessTest, UnwrapErrorOfFunctionCallResultNoCheck) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target() {
+      auto e = Make<$ns::expected<int, int>>();
+      e.error(); // [[unsafe:error]]
+    }
+  )");
+}
+
+TEST_P(UncheckedExpectedAccessTest, UnwrapVoidErrorNoCheck) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target($ns::expected<void, int> e) {
+      e.error(); // [[unsafe:error]]
+    }
+  )");
+}
+
+TEST_P(UncheckedExpectedAccessTest, UnwrapErrorWhenHoldingValue) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target($ns::expected<int, int> e) {
+      if (e) {
+        e.error(); // [[unsafe:error]]
+      }
+    }
+  )");
+
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target($ns::expected<int, int> e) {
+      if (e.has_value()) {
+        e.error(); // [[unsafe:error]]
+      }
+    }
+  )");
+
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target($ns::expected<int, int> e) {
+      if (!e)
+        return;
+      e.error(); // [[unsafe:error]]
+    }
+  )");
+
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    int target($ns::expected<int, int> e) {
+      return e ? e.error() : 0; // [[unsafe:error]]
+    }
+  )");
+}
+
+TEST_P(UncheckedExpectedAccessTest, ErrorCheck) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target($ns::expected<int, int> e) {
+      if (!e) {
+        e.error();
+      }
+    }
+  )");
+
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target($ns::expected<int, int> e) {
+      if (!e.has_value()) {
+        e.error();
+      }
+    }
+  )");
+
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target($ns::expected<int, int> e) {
+      if (e) {
+      } else {
+        e.error();
+      }
+    }
+  )");
+
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target($ns::expected<void, int> e) {
+      if (!e)
+        e.error();
+    }
+  )");
+}
+
+TEST_P(UncheckedExpectedAccessTest, ErrorCheckedAfterEarlyReturn) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    int target($ns::expected<int, int> e) {
+      if (e)
+        return 0;
+      return e.error();
+    }
+  )");
+}
+
+TEST_P(UncheckedExpectedAccessTest, ErrorCheckedInTernary) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    int target($ns::expected<int, int> e) {
+      return e ? 0 : e.error();
+    }
+  )");
+}
+
+TEST_P(UncheckedExpectedAccessTest, ValueAndErrorChecked) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target($ns::expected<int, int> e) {
+      if (e) {
+        *e;
+      } else {
+        e.error();
+      }
+    }
+  )");
+}
+
+TEST_P(UncheckedExpectedAccessTest, ErrorOrIsNotAnAccess) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target($ns::expected<int, int> e) {
+      e.error_or(0);
+    }
+  )");
+}
+
+TEST_P(UncheckedExpectedAccessTest, UnexpectedErrorIsNotAnAccess) {
+  ExpectDiagnosticsFor(R"(
+    #include "unchecked_expected_access_test.h"
+
+    void target() {
+      $ns::unexpected<int> u(1);
+      u.error();
+    }
+  )");
+}

>From ab28ab5440504e0f111ff158c6ccf41cf599f47e Mon Sep 17 00:00:00 2001
From: BaLiKfromUA <valentin.yukhymenko at gmail.com>
Date: Sun, 15 Nov 2026 20:41:43 +0000
Subject: [PATCH 3/3] Basic support of `tl::expected`

Need it for battle-testing on real codebase
---
 .../Models/UncheckedExpectedAccessModel.h     |  21 ++-
 .../Models/UncheckedExpectedAccessModel.cpp   |  27 +++-
 .../Analysis/FlowSensitive/MockHeaders.cpp    | 145 ++++++++++++++++++
 .../UncheckedExpectedAccessModelTest.cpp      |  50 +++++-
 4 files changed, 231 insertions(+), 12 deletions(-)

diff --git a/clang/include/clang/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.h b/clang/include/clang/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.h
index b6d6b0e5e118a6..2928bc172fc24c 100644
--- a/clang/include/clang/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.h
+++ b/clang/include/clang/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.h
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 //
 //  This file defines a dataflow analysis that detects unsafe accesses to the
-//  values of `std::expected` objects.
+//  values of `std::expected` and `tl::expected` objects.
 //
 //===----------------------------------------------------------------------===//
 
@@ -23,17 +23,22 @@
 #include "clang/Analysis/FlowSensitive/NoopLattice.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
 
 namespace clang {
 namespace dataflow {
 
-/// Dataflow analysis that models whether `std::expected` objects hold values.
+/// Dataflow analysis that models whether expected objects hold values.
+///
+/// Supported types are `std::expected` and `tl::expected`
+/// (https://github.com/TartanLlama/expected).
 class UncheckedExpectedAccessModel
     : public DataflowAnalysis<UncheckedExpectedAccessModel, NoopLattice> {
 public:
   UncheckedExpectedAccessModel(ASTContext &Ctx, Environment &Env);
 
-  /// Returns a matcher for calls to member functions of `std::expected`.
+  /// Returns a matcher for calls to member functions of a supported expected
+  /// type.
   static ast_matchers::StatementMatcher callToExpectedClass();
 
   static NoopLattice initialElement() { return {}; }
@@ -44,7 +49,7 @@ class UncheckedExpectedAccessModel
   CFGMatchSwitch<TransferState<NoopLattice>> TransferMatchSwitch;
 };
 
-/// The part of a `std::expected` object that is accessed.
+/// The part of an expected object that is accessed.
 ///
 /// The values are used as `%select` indices in diagnostics, so they must not
 /// be reordered.
@@ -55,14 +60,16 @@ enum class UncheckedExpectedAccessKind : int {
   Error = 1,
 };
 
-/// Diagnostic information for an unchecked `std::expected` access.
+/// Diagnostic information for an unchecked expected access.
 struct UncheckedExpectedAccessDiagnostic {
   SourceLocation Loc;
   UncheckedExpectedAccessKind Kind;
+  /// The accessed type, either "std::expected" or "tl::expected".
+  llvm::StringRef TypeName;
 };
 
-/// Reports accesses to the value (or error) of `std::expected` objects that are
-/// not provably preceded by a check that the object holds a value (or error).
+/// Reports accesses to the value (or error) of expected objects that are not
+/// provably preceded by a check that the object holds a value (or error).
 class UncheckedExpectedAccessDiagnoser {
 public:
   UncheckedExpectedAccessDiagnoser();
diff --git a/clang/lib/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.cpp b/clang/lib/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.cpp
index f9376bafd98d0b..f742fb25e21513 100644
--- a/clang/lib/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.cpp
+++ b/clang/lib/Analysis/FlowSensitive/Models/UncheckedExpectedAccessModel.cpp
@@ -23,9 +23,25 @@
 namespace clang {
 namespace dataflow {
 
+/// Returns true if `DC` is `std` or the top-level `tl` namespace, which holds
+/// `tl::expected` (https://github.com/TartanLlama/expected).
+static bool isSupportedNamespace(const DeclContext &DC) {
+  if (DC.isStdNamespace())
+    return true;
+  const auto *NS = dyn_cast<NamespaceDecl>(&DC);
+  return NS != nullptr && NS->getDeclName().isIdentifier() &&
+         NS->getName() == "tl" && NS->getParent()->isTranslationUnit();
+}
+
 static bool isExpectedClass(const CXXRecordDecl &RD) {
   return RD.getDeclName().isIdentifier() && RD.getName() == "expected" &&
-         RD.getDeclContext()->isStdNamespace();
+         isSupportedNamespace(*RD.getDeclContext());
+}
+
+/// Returns the name of the expected class `RD` to show in diagnostics.
+static llvm::StringRef getExpectedTypeName(const CXXRecordDecl &RD) {
+  return RD.getDeclContext()->isStdNamespace() ? "std::expected"
+                                               : "tl::expected";
 }
 
 // Classes derived from `std::expected` are deliberately not supported.
@@ -89,12 +105,14 @@ auto buildTransferMatchSwitch() {
       .Build();
 }
 
+/// `ExpectedClass` is the class of the called accessor.
 llvm::SmallVector<UncheckedExpectedAccessDiagnostic>
 diagnoseAccess(SourceLocation AccessLoc, UncheckedExpectedAccessKind Kind,
+               const CXXRecordDecl &ExpectedClass,
                const RecordStorageLocation *ExpectedLoc,
                const Environment &Env) {
   if (ExpectedLoc != nullptr) {
-    // Accesses through classes derived from `std::expected` are not modeled.
+    // Accesses through classes derived from an expected are not modeled.
     if (!isExpectedType(ExpectedLoc->getType()))
       return {};
     if (auto *HasValueVal = Env.get<BoolValue>(locForHasValue(*ExpectedLoc))) {
@@ -108,7 +126,7 @@ diagnoseAccess(SourceLocation AccessLoc, UncheckedExpectedAccessKind Kind,
     }
   }
 
-  return {{AccessLoc, Kind}};
+  return {{AccessLoc, Kind, getExpectedTypeName(ExpectedClass)}};
 }
 
 auto buildDiagnoseMatchSwitch() {
@@ -122,6 +140,7 @@ auto buildDiagnoseMatchSwitch() {
              const Environment &Env) {
             return diagnoseAccess(E->getExprLoc(),
                                   UncheckedExpectedAccessKind::Value,
+                                  *E->getMethodDecl()->getParent(),
                                   getImplicitObjectLocation(*E, Env), Env);
           })
       // expected::operator*, expected::operator->
@@ -133,6 +152,7 @@ auto buildDiagnoseMatchSwitch() {
             // expression, so point at the operator token instead.
             return diagnoseAccess(
                 E->getOperatorLoc(), UncheckedExpectedAccessKind::Value,
+                *cast<CXXMethodDecl>(E->getCalleeDecl())->getParent(),
                 Env.get<RecordStorageLocation>(*E->getArg(0)), Env);
           })
       // expected::error
@@ -142,6 +162,7 @@ auto buildDiagnoseMatchSwitch() {
              const Environment &Env) {
             return diagnoseAccess(E->getExprLoc(),
                                   UncheckedExpectedAccessKind::Error,
+                                  *E->getMethodDecl()->getParent(),
                                   getImplicitObjectLocation(*E, Env), Env);
           })
       .Build();
diff --git a/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp b/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp
index 97d77d3dbcac23..f325b913ae2c7f 100644
--- a/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp
+++ b/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp
@@ -945,6 +945,150 @@ template <class E> class expected<void, E> {
 #endif // STD_EXPECTED_H
 )";
 
+static constexpr char TlExpectedHeader[] = R"(
+#ifndef TL_EXPECTED_H
+#define TL_EXPECTED_H
+
+// Mock of `tl::expected` from https://github.com/TartanLlama/expected.
+//
+// Unlike `std::expected`, it has no `void` specialization.
+
+#include "std_type_traits.h"
+
+namespace tl {
+
+template <class T, class E> class expected;
+
+struct in_place_t {
+  explicit in_place_t() = default;
+};
+static constexpr in_place_t in_place{};
+
+template <class E> class unexpected {
+public:
+  unexpected() = delete;
+  explicit unexpected(const E &e);
+  explicit unexpected(E &&e);
+
+  const E &value() const &;
+  E &value() &;
+  E &&value() &&;
+  const E &&value() const &&;
+};
+
+template <class E> unexpected(E) -> unexpected<E>;
+
+template <class E>
+unexpected<typename std::decay<E>::type> make_unexpected(E &&e);
+
+struct unexpect_t {
+  unexpect_t() = default;
+};
+static constexpr unexpect_t unexpect{};
+
+namespace detail {
+
+template <class> constexpr bool is_unexpected = false;
+template <class E> constexpr bool is_unexpected<unexpected<E>> = true;
+
+} // namespace detail
+
+template <class T, class E> class expected {
+public:
+  typedef T value_type;
+  typedef E error_type;
+  typedef unexpected<E> unexpected_type;
+
+  constexpr expected() = default;
+  constexpr expected(const expected &rhs) = default;
+  constexpr expected(expected &&rhs) = default;
+  expected &operator=(const expected &rhs) = default;
+  expected &operator=(expected &&rhs) = default;
+
+  template <class... Args> expected(in_place_t, Args &&...args);
+
+  template <class G> expected(const unexpected<G> &e);
+  template <class G> expected(unexpected<G> &&e);
+
+  template <class... Args> explicit expected(unexpect_t, Args &&...args);
+
+  template <class U, class G,
+            std::enable_if_t<__is_constructible(T, const U &) &&
+                             __is_constructible(E, const G &)> * = nullptr>
+  expected(const expected<U, G> &rhs);
+  template <class U, class G,
+            std::enable_if_t<__is_constructible(T, U &&) &&
+                             __is_constructible(E, G &&)> * = nullptr>
+  expected(expected<U, G> &&rhs);
+
+  template <
+      class U = T,
+      std::enable_if_t<
+          __is_constructible(T, U &&) &&
+          !std::is_same<typename std::decay<U>::type, in_place_t>::value &&
+          !std::is_same<typename std::decay<U>::type, unexpect_t>::value &&
+          !std::is_same<typename std::decay<U>::type, expected>::value &&
+          !detail::is_unexpected<typename std::decay<U>::type>> * = nullptr>
+  expected(U &&v);
+
+  // `G` delays forming `T &`, which is ill-formed for `void`.
+  template <
+      class U = T, class G = T,
+      std::enable_if_t<
+          __is_constructible(T, U &&) && __is_assignable(G &, U &&) &&
+          !std::is_same<typename std::decay<U>::type, expected>::value &&
+          !detail::is_unexpected<typename std::decay<U>::type>> * = nullptr>
+  expected &operator=(U &&v);
+
+  template <class G> expected &operator=(const unexpected<G> &rhs);
+  template <class G> expected &operator=(unexpected<G> &&rhs);
+
+  template <class... Args> void emplace(Args &&...args);
+
+  void swap(expected &rhs);
+
+  const T *operator->() const;
+  T *operator->();
+
+  template <class U = T,
+            std::enable_if_t<!std::is_void<U>::value> * = nullptr>
+  const U &operator*() const &;
+  template <class U = T,
+            std::enable_if_t<!std::is_void<U>::value> * = nullptr>
+  U &operator*() &;
+  template <class U = T,
+            std::enable_if_t<!std::is_void<U>::value> * = nullptr>
+  U &&operator*() &&;
+
+  bool has_value() const noexcept;
+  explicit operator bool() const noexcept;
+
+  template <class U = T,
+            std::enable_if_t<!std::is_void<U>::value> * = nullptr>
+  const U &value() const &;
+  template <class U = T,
+            std::enable_if_t<!std::is_void<U>::value> * = nullptr>
+  U &value() &;
+  template <class U = T,
+            std::enable_if_t<!std::is_void<U>::value> * = nullptr>
+  U &&value() &&;
+
+  const E &error() const &;
+  E &error() &;
+  E &&error() &&;
+
+  template <class U> T value_or(U &&v) const &;
+  template <class U> T value_or(U &&v) &&;
+};
+
+template <class T, class E>
+void swap(expected<T, E> &lhs, expected<T, E> &rhs);
+
+} // namespace tl
+
+#endif // TL_EXPECTED_H
+)";
+
 static constexpr char AbslOptionalHeader[] = R"(
 #include "absl_type_traits.h"
 #include "std_initializer_list.h"
@@ -2629,6 +2773,7 @@ std::vector<std::pair<std::string, std::string>> getMockHeaders() {
   Headers.emplace_back("std_utility.h", StdUtilityHeader);
   Headers.emplace_back("std_optional.h", StdOptionalHeader);
   Headers.emplace_back("std_expected.h", StdExpectedHeader);
+  Headers.emplace_back("tl_expected.h", TlExpectedHeader);
   Headers.emplace_back("std_coroutine.h", StdCoroutineHeader);
   Headers.emplace_back("absl_type_traits.h", AbslTypeTraitsHeader);
   Headers.emplace_back("absl_optional.h", AbslOptionalHeader);
diff --git a/clang/unittests/Analysis/FlowSensitive/UncheckedExpectedAccessModelTest.cpp b/clang/unittests/Analysis/FlowSensitive/UncheckedExpectedAccessModelTest.cpp
index 409f0e918731ed..96b3c093e5212b 100644
--- a/clang/unittests/Analysis/FlowSensitive/UncheckedExpectedAccessModelTest.cpp
+++ b/clang/unittests/Analysis/FlowSensitive/UncheckedExpectedAccessModelTest.cpp
@@ -76,6 +76,7 @@ class UncheckedExpectedAccessTest
     Headers.emplace_back("unchecked_expected_access_test.h", R"(
       #include "std_expected.h"
       #include "std_utility.h"
+      #include "tl_expected.h"
 
       template <typename T>
       T Make();
@@ -101,7 +102,8 @@ class UncheckedExpectedAccessTest
                 {"-fsyntax-only", CxxMode, "-Wno-undefined-inline"})
             .withASTBuildVirtualMappedFiles(
                 tooling::FileContentMappings(Headers.begin(), Headers.end())),
-        /*VerifyResults=*/[&Diagnostics](
+        /*VerifyResults=*/[&Diagnostics,
+                           TypeName = GetParam().NamespaceName + "::expected"](
                               const llvm::DenseMap<unsigned, std::string>
                                   &Annotations,
                               const AnalysisOutputs &AO) {
@@ -127,6 +129,7 @@ class UncheckedExpectedAccessTest
                       ? UncheckedExpectedAccessKind::Error
                       : UncheckedExpectedAccessKind::Value;
               EXPECT_EQ(Diag.Kind, ExpectedKind) << "on line " << Line;
+              EXPECT_EQ(Diag.TypeName, TypeName) << "on line " << Line;
             }
           }
 
@@ -139,11 +142,33 @@ class UncheckedExpectedAccessTest
 
 INSTANTIATE_TEST_SUITE_P(
     UncheckedExpectedUseTestInst, UncheckedExpectedAccessTest,
-    ::testing::Values(ExpectedTypeIdentifier{"std"}),
+    ::testing::Values(ExpectedTypeIdentifier{"std"},
+                      ExpectedTypeIdentifier{"tl"}),
     [](const ::testing::TestParamInfo<ExpectedTypeIdentifier> &Info) {
       return Info.param.NamespaceName;
     });
 
+// Verifies that similarly-named types are ignored.
+TEST_P(UncheckedExpectedAccessTest, NonTrackedExpectedType) {
+  ExpectDiagnosticsFor(
+      R"(
+    namespace other {
+    namespace $ns {
+    template <typename T, typename E>
+    struct expected {
+      T value();
+      E error();
+    };
+    }
+
+    void target($ns::expected<int, int> e) {
+      e.value();
+      e.error();
+    }
+    }
+  )");
+}
+
 TEST_P(UncheckedExpectedAccessTest, EmptyFunctionBody) {
   ExpectDiagnosticsFor(R"(
     void target() {
@@ -226,6 +251,10 @@ TEST_P(UncheckedExpectedAccessTest, UnwrapFunctionCallResultNoCheck) {
 }
 
 TEST_P(UncheckedExpectedAccessTest, UnwrapVoidUsingValueNoCheck) {
+  // `tl::expected<void, E>` has no `value()`.
+  if (GetParam().NamespaceName != "std")
+    GTEST_SKIP();
+
   ExpectDiagnosticsFor(R"(
     #include "unchecked_expected_access_test.h"
 
@@ -507,6 +536,10 @@ TEST_P(UncheckedExpectedAccessTest, ValueAndErrorChecked) {
 }
 
 TEST_P(UncheckedExpectedAccessTest, ErrorOrIsNotAnAccess) {
+  // `tl::expected` has no `error_or()`.
+  if (GetParam().NamespaceName != "std")
+    GTEST_SKIP();
+
   ExpectDiagnosticsFor(R"(
     #include "unchecked_expected_access_test.h"
 
@@ -517,6 +550,19 @@ TEST_P(UncheckedExpectedAccessTest, ErrorOrIsNotAnAccess) {
 }
 
 TEST_P(UncheckedExpectedAccessTest, UnexpectedErrorIsNotAnAccess) {
+  // `tl::unexpected` names its accessor `value()`.
+  if (GetParam().NamespaceName == "tl") {
+    ExpectDiagnosticsFor(R"(
+      #include "unchecked_expected_access_test.h"
+
+      void target() {
+        $ns::unexpected<int> u(1);
+        u.value();
+      }
+    )");
+    return;
+  }
+
   ExpectDiagnosticsFor(R"(
     #include "unchecked_expected_access_test.h"
 



More information about the cfe-commits mailing list