| //===- 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 "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 <optional> |
| #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 OptionalTypeIdentifier { |
| std::string NamespaceName; |
| std::string TypeName; |
| }; |
| |
| static raw_ostream &operator<<(raw_ostream &OS, |
| const OptionalTypeIdentifier &TypeId) { |
| OS << TypeId.NamespaceName << "::" << TypeId.TypeName; |
| return OS; |
| } |
| |
| class UncheckedOptionalAccessTest |
| : public ::testing::TestWithParam<OptionalTypeIdentifier> { |
| 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. |
| // - Given "// [[unsafe:range_text]]" annotations on a line, we expect a |
| // diagnostic on that line, and we expect the diagnostic Range (printed as |
| // a string) to match the "range_text". |
| void ExpectDiagnosticsFor(std::string SourceCode, |
| bool IgnoreSmartPointerDereference = true) { |
| ExpectDiagnosticsFor(SourceCode, ast_matchers::hasName("target"), |
| IgnoreSmartPointerDereference); |
| } |
| |
| void ExpectDiagnosticsForLambda(std::string SourceCode, |
| bool IgnoreSmartPointerDereference = true) { |
| ExpectDiagnosticsFor( |
| SourceCode, |
| ast_matchers::hasDeclContext( |
| ast_matchers::cxxRecordDecl(ast_matchers::isLambda())), |
| IgnoreSmartPointerDereference); |
| } |
| |
| template <typename FuncDeclMatcher> |
| void ExpectDiagnosticsFor(std::string SourceCode, FuncDeclMatcher FuncMatcher, |
| bool IgnoreSmartPointerDereference = true) { |
| // 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, FuncMatcher, CxxMode, |
| IgnoreSmartPointerDereference); |
| } |
| |
| template <typename FuncDeclMatcher> |
| void ExpectDiagnosticsFor(std::string SourceCode, FuncDeclMatcher FuncMatcher, |
| const char *CxxMode, |
| bool IgnoreSmartPointerDereference) { |
| ReplaceAllOccurrences(SourceCode, "$ns", GetParam().NamespaceName); |
| ReplaceAllOccurrences(SourceCode, "$optional", GetParam().TypeName); |
| |
| auto Headers = getMockHeaders(); |
| Headers.emplace_back("unchecked_optional_access_test.h", R"( |
| #include "absl_optional.h" |
| #include "base_optional.h" |
| #include "std_initializer_list.h" |
| #include "std_optional.h" |
| #include "std_string.h" |
| #include "std_utility.h" |
| |
| template <typename T> |
| T Make(); |
| )"); |
| UncheckedOptionalAccessModelOptions Options{IgnoreSmartPointerDereference}; |
| std::vector<UncheckedOptionalAccessDiagnostic> Diagnostics; |
| llvm::Error Error = checkDataflow<UncheckedOptionalAccessModel>( |
| AnalysisInputs<UncheckedOptionalAccessModel>( |
| SourceCode, std::move(FuncMatcher), |
| [](ASTContext &Ctx, Environment &Env) { |
| return UncheckedOptionalAccessModel(Ctx, Env); |
| }) |
| .withDiagnosisCallbacks( |
| {/*Before=*/[&Diagnostics, |
| Diagnoser = |
| UncheckedOptionalAccessDiagnoser(Options)]( |
| ASTContext &Ctx, const CFGElement &Elt, |
| const TransferStateForDiagnostics< |
| UncheckedOptionalAccessLattice> |
| &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; |
| llvm::DenseMap<unsigned, std::string> AnnotationRangesInLines; |
| for (const auto &[Line, AnnotationWithMaybeRange] : Annotations) { |
| AnnotationLines.insert(Line); |
| auto it = AnnotationWithMaybeRange.find(':'); |
| if (it != std::string::npos) { |
| AnnotationRangesInLines[Line] = |
| AnnotationWithMaybeRange.substr(it + 1); |
| } |
| } |
| auto &SrcMgr = AO.ASTCtx.getSourceManager(); |
| llvm::DenseSet<unsigned> DiagnosticLines; |
| for (const UncheckedOptionalAccessDiagnostic &Diag : Diagnostics) { |
| unsigned Line = SrcMgr.getPresumedLineNumber(Diag.Range.getBegin()); |
| DiagnosticLines.insert(Line); |
| if (!AnnotationLines.contains(Line)) { |
| DiagnosticOptions DiagOpts; |
| TextDiagnostic TD(llvm::errs(), AO.ASTCtx.getLangOpts(), |
| DiagOpts); |
| TD.emitDiagnostic(FullSourceLoc(Diag.Range.getBegin(), SrcMgr), |
| DiagnosticsEngine::Error, |
| "unexpected diagnostic", {Diag.Range}, {}); |
| } else { |
| auto it = AnnotationRangesInLines.find(Line); |
| if (it != AnnotationRangesInLines.end()) { |
| EXPECT_EQ(Diag.Range.getAsRange().printToString(SrcMgr), |
| it->second); |
| } |
| } |
| } |
| |
| EXPECT_THAT(DiagnosticLines, ContainerEq(AnnotationLines)); |
| }); |
| 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; |
| }); |
| |
| // Verifies that similarly-named types are ignored. |
| TEST_P(UncheckedOptionalAccessTest, NonTrackedOptionalType) { |
| ExpectDiagnosticsFor( |
| R"( |
| namespace other { |
| namespace $ns { |
| template <typename T> |
| struct $optional { |
| T value(); |
| }; |
| } |
| |
| void target($ns::$optional<int> opt) { |
| opt.value(); |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, EmptyFunctionBody) { |
| ExpectDiagnosticsFor(R"( |
| void target() { |
| (void)0; |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, UnwrapUsingValueNoCheck) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target($ns::$optional<int> opt) { |
| opt.value(); // [[unsafe]] |
| } |
| )"); |
| |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target($ns::$optional<int> opt) { |
| std::move(opt).value(); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, UnwrapUsingOperatorStarNoCheck) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target($ns::$optional<int> opt) { |
| *opt; // [[unsafe]] |
| } |
| )"); |
| |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target($ns::$optional<int> opt) { |
| *std::move(opt); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, UnwrapUsingOperatorArrowNoCheck) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct Foo { |
| void foo(); |
| }; |
| |
| void target($ns::$optional<Foo> opt) { |
| opt->foo(); // [[unsafe]] |
| } |
| )"); |
| |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct Foo { |
| void foo(); |
| }; |
| |
| void target($ns::$optional<Foo> opt) { |
| std::move(opt)->foo(); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, HasValueCheck) { |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target($ns::$optional<int> opt) { |
| if (opt.has_value()) { |
| opt.value(); |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, OperatorBoolCheck) { |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target($ns::$optional<int> opt) { |
| if (opt) { |
| opt.value(); |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, UnwrapFunctionCallResultNoCheck) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| Make<$ns::$optional<int>>().value(); // [[unsafe]] |
| (void)0; |
| } |
| )"); |
| |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target($ns::$optional<int> opt) { |
| std::move(opt).value(); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, DefaultConstructor) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt; |
| opt.value(); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, NulloptConstructor) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt($ns::nullopt); |
| opt.value(); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, NulloptConstructorWithSugaredType) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| template <typename T> |
| using wrapper = T; |
| |
| template <typename T> |
| wrapper<T> wrap(T); |
| |
| void target() { |
| $ns::$optional<int> opt(wrap($ns::nullopt)); |
| opt.value(); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, InPlaceConstructor) { |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt($ns::in_place, 3); |
| opt.value(); |
| } |
| )"); |
| |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct Foo {}; |
| |
| void target() { |
| $ns::$optional<Foo> opt($ns::in_place); |
| opt.value(); |
| } |
| )"); |
| |
| ExpectDiagnosticsFor(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(); |
| } |
| )"); |
| |
| ExpectDiagnosticsFor(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(); |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ValueConstructor) { |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt(21); |
| opt.value(); |
| } |
| )"); |
| |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt = $ns::$optional<int>(21); |
| opt.value(); |
| } |
| )"); |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<$ns::$optional<int>> opt(Make<$ns::$optional<int>>()); |
| opt.value(); |
| } |
| )"); |
| |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct MyString { |
| MyString(const char*); |
| }; |
| |
| void target() { |
| $ns::$optional<MyString> opt("foo"); |
| opt.value(); |
| } |
| )"); |
| |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct Foo {}; |
| |
| struct Bar { |
| Bar(const Foo&); |
| }; |
| |
| void target() { |
| $ns::$optional<Bar> opt(Make<Foo>()); |
| opt.value(); |
| } |
| )"); |
| |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct Foo { |
| explicit Foo(int); |
| }; |
| |
| void target() { |
| $ns::$optional<Foo> opt(3); |
| opt.value(); |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ConvertibleOptionalConstructor) { |
| ExpectDiagnosticsFor( |
| 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(); // [[unsafe]] |
| } |
| )"); |
| |
| ExpectDiagnosticsFor( |
| 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(); // [[unsafe]] |
| } |
| )"); |
| |
| ExpectDiagnosticsFor( |
| 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(); // [[unsafe]] |
| } |
| )"); |
| |
| ExpectDiagnosticsFor(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(); |
| } |
| )"); |
| |
| ExpectDiagnosticsFor(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(); |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, MakeOptional) { |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt = $ns::make_optional(0); |
| opt.value(); |
| } |
| )"); |
| |
| ExpectDiagnosticsFor(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(); |
| } |
| )"); |
| |
| ExpectDiagnosticsFor(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(); |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ValueOr) { |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt; |
| opt.value_or(0); |
| (void)0; |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ValueOrComparisonPointers) { |
| ExpectDiagnosticsFor( |
| R"code( |
| #include "unchecked_optional_access_test.h" |
| |
| void target($ns::$optional<int*> opt) { |
| if (opt.value_or(nullptr) != nullptr) { |
| opt.value(); |
| } else { |
| opt.value(); // [[unsafe]] |
| } |
| } |
| )code"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ValueOrComparisonIntegers) { |
| ExpectDiagnosticsFor( |
| R"code( |
| #include "unchecked_optional_access_test.h" |
| |
| void target($ns::$optional<int> opt) { |
| if (opt.value_or(0) != 0) { |
| opt.value(); |
| } else { |
| opt.value(); // [[unsafe]] |
| } |
| } |
| )code"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ValueOrComparisonStrings) { |
| ExpectDiagnosticsFor( |
| R"code( |
| #include "unchecked_optional_access_test.h" |
| |
| void target($ns::$optional<std::string> opt) { |
| if (!opt.value_or("").empty()) { |
| opt.value(); |
| } else { |
| opt.value(); // [[unsafe]] |
| } |
| } |
| )code"); |
| |
| ExpectDiagnosticsFor( |
| R"code( |
| #include "unchecked_optional_access_test.h" |
| |
| void target($ns::$optional<std::string> opt) { |
| if (opt.value_or("") != "") { |
| opt.value(); |
| } else { |
| opt.value(); // [[unsafe]] |
| } |
| } |
| )code"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ValueOrComparisonPointerToOptional) { |
| // FIXME: make `opt` a parameter directly, once we ensure that all `optional` |
| // values have a `has_value` property. |
| ExpectDiagnosticsFor( |
| 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(); |
| } else { |
| opt->value(); // [[unsafe]] |
| } |
| } |
| )code"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, Emplace) { |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt; |
| opt.emplace(0); |
| opt.value(); |
| } |
| )"); |
| |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target($ns::$optional<int> *opt) { |
| opt->emplace(0); |
| opt->value(); |
| } |
| )"); |
| |
| // FIXME: Add tests that call `emplace` in conditional branches: |
| // ExpectDiagnosticsFor( |
| // R"( |
| // #include "unchecked_optional_access_test.h" |
| // |
| // void target($ns::$optional<int> opt, bool b) { |
| // if (b) { |
| // opt.emplace(0); |
| // } |
| // if (b) { |
| // opt.value(); |
| // } else { |
| // opt.value(); // [[unsafe]] |
| // } |
| // } |
| // )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, Reset) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt = $ns::make_optional(0); |
| opt.reset(); |
| opt.value(); // [[unsafe]] |
| } |
| )"); |
| |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target($ns::$optional<int> &opt) { |
| if (opt.has_value()) { |
| opt.reset(); |
| opt.value(); // [[unsafe]] |
| } |
| } |
| )"); |
| |
| // FIXME: Add tests that call `reset` in conditional branches: |
| // ExpectDiagnosticsFor( |
| // 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(); // [[unsafe]] |
| // } else { |
| // opt.value(); |
| // } |
| // } |
| // )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ValueAssignment) { |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct Foo {}; |
| |
| void target() { |
| $ns::$optional<Foo> opt; |
| opt = Foo(); |
| opt.value(); |
| } |
| )"); |
| |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct Foo {}; |
| |
| void target() { |
| $ns::$optional<Foo> opt; |
| (opt = Foo()).value(); |
| (void)0; |
| } |
| )"); |
| |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct MyString { |
| MyString(const char*); |
| }; |
| |
| void target() { |
| $ns::$optional<MyString> opt; |
| opt = "foo"; |
| opt.value(); |
| } |
| )"); |
| |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct MyString { |
| MyString(const char*); |
| }; |
| |
| void target() { |
| $ns::$optional<MyString> opt; |
| (opt = "foo").value(); |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, OptionalConversionAssignment) { |
| ExpectDiagnosticsFor( |
| 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(); |
| } |
| )"); |
| |
| ExpectDiagnosticsFor( |
| 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(); // [[unsafe]] |
| } |
| } |
| )"); |
| |
| ExpectDiagnosticsFor( |
| 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; |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, NulloptAssignment) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt = 3; |
| opt = $ns::nullopt; |
| opt.value(); // [[unsafe]] |
| } |
| )"); |
| |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt = 3; |
| (opt = $ns::nullopt).value(); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, OptionalSwap) { |
| ExpectDiagnosticsFor( |
| 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(); |
| |
| opt2.value(); // [[unsafe]] |
| } |
| )"); |
| |
| ExpectDiagnosticsFor( |
| 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(); |
| |
| opt2.value(); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, OptionalReturnedFromFuntionCall) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct S { |
| $ns::$optional<float> x; |
| } s; |
| S getOptional() { |
| return s; |
| } |
| |
| void target() { |
| getOptional().x = 0; |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, NonConstMethodMayClearOptionalField) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct Foo { |
| $ns::$optional<std::string> opt; |
| void clear(); // assume this may modify the opt field's state |
| }; |
| |
| void target(Foo& foo) { |
| if (foo.opt) { |
| foo.opt.value(); |
| foo.clear(); |
| foo.opt.value(); // [[unsafe]] |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, |
| NonConstMethodMayNotClearConstOptionalField) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct Foo { |
| const $ns::$optional<std::string> opt; |
| void clear(); |
| }; |
| |
| void target(Foo& foo) { |
| if (foo.opt) { |
| foo.opt.value(); |
| foo.clear(); |
| foo.opt.value(); |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, StdSwap) { |
| ExpectDiagnosticsFor( |
| 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(); |
| |
| opt2.value(); // [[unsafe]] |
| } |
| )"); |
| |
| ExpectDiagnosticsFor( |
| 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(); |
| |
| opt2.value(); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, SwapUnmodeledLocLeft) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct L { $ns::$optional<int> hd; L* tl; }; |
| |
| void target() { |
| $ns::$optional<int> foo = 3; |
| L bar; |
| |
| // Any `tl` beyond the first is not modeled. |
| bar.tl->tl->hd.swap(foo); |
| |
| bar.tl->tl->hd.value(); // [[unsafe]] |
| foo.value(); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, SwapUnmodeledLocRight) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct L { $ns::$optional<int> hd; L* tl; }; |
| |
| void target() { |
| $ns::$optional<int> foo = 3; |
| L bar; |
| |
| // Any `tl` beyond the first is not modeled. |
| foo.swap(bar.tl->tl->hd); |
| |
| bar.tl->tl->hd.value(); // [[unsafe]] |
| foo.value(); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, SwapUnmodeledValueLeftSet) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct S { int x; }; |
| struct A { $ns::$optional<S> late; }; |
| struct B { A f3; }; |
| struct C { B f2; }; |
| struct D { C f1; }; |
| |
| void target() { |
| $ns::$optional<S> foo = S{3}; |
| D bar; |
| |
| bar.f1.f2.f3.late.swap(foo); |
| |
| bar.f1.f2.f3.late.value(); |
| foo.value(); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, SwapUnmodeledValueLeftUnset) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct S { int x; }; |
| struct A { $ns::$optional<S> late; }; |
| struct B { A f3; }; |
| struct C { B f2; }; |
| struct D { C f1; }; |
| |
| void target() { |
| $ns::$optional<S> foo; |
| D bar; |
| |
| bar.f1.f2.f3.late.swap(foo); |
| |
| bar.f1.f2.f3.late.value(); // [[unsafe]] |
| foo.value(); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| // fixme: use recursion instead of depth. |
| TEST_P(UncheckedOptionalAccessTest, SwapUnmodeledValueRightSet) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct S { int x; }; |
| struct A { $ns::$optional<S> late; }; |
| struct B { A f3; }; |
| struct C { B f2; }; |
| struct D { C f1; }; |
| |
| void target() { |
| $ns::$optional<S> foo = S{3}; |
| D bar; |
| |
| foo.swap(bar.f1.f2.f3.late); |
| |
| bar.f1.f2.f3.late.value(); |
| foo.value(); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, SwapUnmodeledValueRightUnset) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct S { int x; }; |
| struct A { $ns::$optional<S> late; }; |
| struct B { A f3; }; |
| struct C { B f2; }; |
| struct D { C f1; }; |
| |
| void target() { |
| $ns::$optional<S> foo; |
| D bar; |
| |
| foo.swap(bar.f1.f2.f3.late); |
| |
| bar.f1.f2.f3.late.value(); // [[unsafe]] |
| foo.value(); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, UniquePtrToOptional) { |
| // We suppress diagnostics for optionals in smart pointers (other than |
| // `optional` itself). |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| template <typename T> |
| struct smart_ptr { |
| T& operator*() &; |
| T* operator->(); |
| }; |
| |
| void target() { |
| smart_ptr<$ns::$optional<bool>> foo; |
| foo->value(); |
| (*foo).value(); |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, UniquePtrToStructWithOptionalField) { |
| // We suppress diagnostics for optional fields reachable from smart pointers |
| // (other than `optional` itself) through (exactly) one member access. |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| template <typename T> |
| struct smart_ptr { |
| T& operator*() &; |
| T* operator->(); |
| }; |
| |
| struct Foo { |
| $ns::$optional<int> opt; |
| }; |
| |
| void target() { |
| smart_ptr<Foo> foo; |
| *foo->opt; |
| *(*foo).opt; |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, CallReturningOptional) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| $ns::$optional<int> MakeOpt(); |
| |
| void target() { |
| $ns::$optional<int> opt = 0; |
| opt = MakeOpt(); |
| opt.value(); // [[unsafe]] |
| } |
| )"); |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| const $ns::$optional<int>& MakeOpt(); |
| |
| void target() { |
| $ns::$optional<int> opt = 0; |
| opt = MakeOpt(); |
| opt.value(); // [[unsafe]] |
| } |
| )"); |
| |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| using IntOpt = $ns::$optional<int>; |
| IntOpt MakeOpt(); |
| |
| void target() { |
| IntOpt opt = 0; |
| opt = MakeOpt(); |
| opt.value(); // [[unsafe]] |
| } |
| )"); |
| |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| using IntOpt = $ns::$optional<int>; |
| const IntOpt& MakeOpt(); |
| |
| void target() { |
| IntOpt opt = 0; |
| opt = MakeOpt(); |
| opt.value(); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| |
| TEST_P(UncheckedOptionalAccessTest, EqualityCheckLeftSet) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt1 = 3; |
| $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); |
| |
| if (opt1 == opt2) { |
| opt2.value(); |
| } else { |
| opt2.value(); // [[unsafe]] |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, EqualityCheckRightSet) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt1 = 3; |
| $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); |
| |
| if (opt2 == opt1) { |
| opt2.value(); |
| } else { |
| opt2.value(); // [[unsafe]] |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, EqualityCheckVerifySetAfterEq) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt1 = Make<$ns::$optional<int>>(); |
| $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); |
| |
| if (opt1 == opt2) { |
| if (opt1.has_value()) |
| opt2.value(); |
| if (opt2.has_value()) |
| opt1.value(); |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, EqualityCheckLeftUnset) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt1 = $ns::nullopt; |
| $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); |
| |
| if (opt1 == opt2) { |
| opt2.value(); // [[unsafe]] |
| } else { |
| opt2.value(); |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, EqualityCheckRightUnset) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt1 = $ns::nullopt; |
| $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); |
| |
| if (opt2 == opt1) { |
| opt2.value(); // [[unsafe]] |
| } else { |
| opt2.value(); |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, EqualityCheckRightNullopt) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt = Make<$ns::$optional<int>>(); |
| |
| if (opt == $ns::nullopt) { |
| opt.value(); // [[unsafe]] |
| } else { |
| opt.value(); |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, EqualityCheckLeftNullopt) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt = Make<$ns::$optional<int>>(); |
| |
| if ($ns::nullopt == opt) { |
| opt.value(); // [[unsafe]] |
| } else { |
| opt.value(); |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, EqualityCheckRightValue) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt = Make<$ns::$optional<int>>(); |
| |
| if (opt == 3) { |
| opt.value(); |
| } else { |
| opt.value(); // [[unsafe]] |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, EqualityCheckLeftValue) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt = Make<$ns::$optional<int>>(); |
| |
| if (3 == opt) { |
| opt.value(); |
| } else { |
| opt.value(); // [[unsafe]] |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, InequalityCheckLeftSet) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt1 = 3; |
| $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); |
| |
| if (opt1 != opt2) { |
| opt2.value(); // [[unsafe]] |
| } else { |
| opt2.value(); |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, InequalityCheckRightSet) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt1 = 3; |
| $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); |
| |
| if (opt2 != opt1) { |
| opt2.value(); // [[unsafe]] |
| } else { |
| opt2.value(); |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, InequalityCheckVerifySetAfterEq) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt1 = Make<$ns::$optional<int>>(); |
| $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); |
| |
| if (opt1 != opt2) { |
| if (opt1.has_value()) |
| opt2.value(); // [[unsafe]] |
| if (opt2.has_value()) |
| opt1.value(); // [[unsafe]] |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, InequalityCheckLeftUnset) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt1 = $ns::nullopt; |
| $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); |
| |
| if (opt1 != opt2) { |
| opt2.value(); |
| } else { |
| opt2.value(); // [[unsafe]] |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, InequalityCheckRightUnset) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt1 = $ns::nullopt; |
| $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); |
| |
| if (opt2 != opt1) { |
| opt2.value(); |
| } else { |
| opt2.value(); // [[unsafe]] |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, InequalityCheckRightNullopt) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt = Make<$ns::$optional<int>>(); |
| |
| if (opt != $ns::nullopt) { |
| opt.value(); |
| } else { |
| opt.value(); // [[unsafe]] |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, InequalityCheckLeftNullopt) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt = Make<$ns::$optional<int>>(); |
| |
| if ($ns::nullopt != opt) { |
| opt.value(); |
| } else { |
| opt.value(); // [[unsafe]] |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, InequalityCheckRightValue) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt = Make<$ns::$optional<int>>(); |
| |
| if (opt != 3) { |
| opt.value(); // [[unsafe]] |
| } else { |
| opt.value(); |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, InequalityCheckLeftValue) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt = Make<$ns::$optional<int>>(); |
| |
| if (3 != opt) { |
| opt.value(); // [[unsafe]] |
| } else { |
| opt.value(); |
| } |
| } |
| )"); |
| } |
| |
| // Verifies that the model sees through aliases. |
| TEST_P(UncheckedOptionalAccessTest, WithAlias) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| template <typename T> |
| using MyOptional = $ns::$optional<T>; |
| |
| void target(MyOptional<int> opt) { |
| opt.value(); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| 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. |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| using Foo = $ns::$optional<std::string>; |
| |
| void target($ns::$optional<Foo> foo) { |
| if (foo && *foo) { |
| foo->value(); |
| } |
| } |
| )"); |
| |
| // Mutation is supported for nested values. |
| ExpectDiagnosticsFor( |
| 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(); // [[unsafe]] |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, NestedOptionalAssignValue) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| using OptionalInt = $ns::$optional<int>; |
| |
| void target($ns::$optional<OptionalInt> opt) { |
| if (!opt) return; |
| |
| // Accessing the outer optional is OK now. |
| *opt; |
| |
| // But accessing the nested optional is still unsafe because we haven't |
| // checked it. |
| **opt; // [[unsafe]] |
| |
| *opt = 1; |
| |
| // Accessing the nested optional is safe after assigning a value to it. |
| **opt; |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, NestedOptionalAssignOptional) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| using OptionalInt = $ns::$optional<int>; |
| |
| void target($ns::$optional<OptionalInt> opt) { |
| if (!opt) return; |
| |
| // Accessing the outer optional is OK now. |
| *opt; |
| |
| // But accessing the nested optional is still unsafe because we haven't |
| // checked it. |
| **opt; // [[unsafe]] |
| |
| // Assign from `optional<short>` so that we trigger conversion assignment |
| // instead of move assignment. |
| *opt = $ns::$optional<short>(); |
| |
| // Accessing the nested optional is still unsafe after assigning an empty |
| // optional to it. |
| **opt; // [[unsafe]] |
| } |
| )"); |
| } |
| |
| // 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) { |
| ExpectDiagnosticsFor( |
| 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(); |
| } |
| } |
| )"); |
| } |
| |
| // FIXME: A case that we should handle but currently don't. |
| // When there is a field of type reference to non-optional, we may |
| // stop recursively creating storage locations. |
| // E.g., the field `second` below in `pair` should eventually lead to |
| // the optional `x` in `A`. |
| TEST_P(UncheckedOptionalAccessTest, NestedOptionalThroughNonOptionalRefField) { |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| $ns::$optional<int> x; |
| }; |
| |
| struct pair { |
| int first; |
| const A &second; |
| }; |
| |
| struct B { |
| $ns::$optional<pair>& nonConstGetRef(); |
| }; |
| |
| void target(B b) { |
| const auto& maybe_pair = b.nonConstGetRef(); |
| if (!maybe_pair.has_value()) |
| return; |
| |
| if(!maybe_pair->second.x.has_value()) |
| return; |
| maybe_pair->second.x.value(); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, OptionalValueInitialization) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| using Foo = $ns::$optional<std::string>; |
| |
| void target($ns::$optional<Foo> foo, bool b) { |
| if (!foo.has_value()) return; |
| if (b) { |
| if (!foo->has_value()) return; |
| // We have created `foo.value()`. |
| foo->value(); |
| } else { |
| if (!foo->has_value()) return; |
| // We have created `foo.value()` again, in a different environment. |
| foo->value(); |
| } |
| // Now we merge the two values. UncheckedOptionalAccessModel::merge() will |
| // throw away the "value" property. |
| foo->value(); |
| } |
| )"); |
| } |
| |
| // This test is aimed at the core model, not the diagnostic. It is a regression |
| // test against a crash when using non-trivial smart pointers, like |
| // `std::unique_ptr`. As such, it doesn't test the access itself, which would be |
| // ignored regardless because of `IgnoreSmartPointerDereference = true`, above. |
| TEST_P(UncheckedOptionalAccessTest, AssignThroughLvalueReferencePtr) { |
| ExpectDiagnosticsFor( |
| 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<int>> x; |
| // Verify that this assignment does not crash. |
| *x = 3; |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, CorrelatedBranches) { |
| ExpectDiagnosticsFor(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(); |
| } |
| } |
| } |
| )code"); |
| |
| ExpectDiagnosticsFor(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(); |
| } |
| } |
| )code"); |
| |
| ExpectDiagnosticsFor( |
| 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(); // [[unsafe]] |
| } |
| } |
| )code"); |
| |
| ExpectDiagnosticsFor(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(); |
| } |
| } |
| )code"); |
| |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target(bool b, $ns::$optional<int> opt) { |
| if (opt.has_value() == b) { |
| if (b) { |
| opt.value(); |
| } |
| } |
| } |
| )"); |
| |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target(bool b, $ns::$optional<int> opt) { |
| if (opt.has_value() != b) { |
| if (!b) { |
| opt.value(); |
| } |
| } |
| } |
| )"); |
| |
| ExpectDiagnosticsFor(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(); |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, JoinDistinctValues) { |
| ExpectDiagnosticsFor( |
| 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(); |
| } else { |
| opt.value(); // [[unsafe]] |
| } |
| } |
| )code"); |
| |
| ExpectDiagnosticsFor(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(); |
| } |
| )code"); |
| |
| ExpectDiagnosticsFor( |
| 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(); // [[unsafe]] |
| } |
| )code"); |
| |
| ExpectDiagnosticsFor( |
| 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(); |
| } |
| )code"); |
| |
| ExpectDiagnosticsFor( |
| 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(); // [[unsafe]] |
| } |
| )code"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, AccessValueInLoop) { |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt = 3; |
| while (Make<bool>()) { |
| opt.value(); |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ReassignValueInLoopWithCheckSafe) { |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt = 3; |
| while (Make<bool>()) { |
| opt.value(); |
| |
| opt = Make<$ns::$optional<int>>(); |
| if (!opt.has_value()) return; |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ReassignValueInLoopNoCheckUnsafe) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt = 3; |
| while (Make<bool>()) { |
| opt.value(); // [[unsafe]] |
| |
| opt = Make<$ns::$optional<int>>(); |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ReassignValueInLoopToUnsetUnsafe) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt = 3; |
| while (Make<bool>()) |
| opt = $ns::nullopt; |
| $ns::$optional<int> opt2 = $ns::nullopt; |
| if (opt.has_value()) |
| opt2 = $ns::$optional<int>(3); |
| opt2.value(); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ReassignValueInLoopToSetUnsafe) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt = $ns::nullopt; |
| while (Make<bool>()) |
| opt = $ns::$optional<int>(3); |
| $ns::$optional<int> opt2 = $ns::nullopt; |
| if (!opt.has_value()) |
| opt2 = $ns::$optional<int>(3); |
| opt2.value(); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ReassignValueInLoopToUnknownUnsafe) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt = $ns::nullopt; |
| while (Make<bool>()) |
| opt = Make<$ns::$optional<int>>(); |
| $ns::$optional<int> opt2 = $ns::nullopt; |
| if (!opt.has_value()) |
| opt2 = $ns::$optional<int>(3); |
| opt2.value(); // [[unsafe]] |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ReassignValueInLoopBadConditionUnsafe) { |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| $ns::$optional<int> opt = 3; |
| while (Make<bool>()) { |
| opt.value(); // [[unsafe]] |
| |
| opt = Make<$ns::$optional<int>>(); |
| if (!opt.has_value()) continue; |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, StructuredBindingsFromStruct) { |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct kv { $ns::$optional<int> opt; int x; }; |
| int target() { |
| auto [contents, x] = Make<kv>(); |
| return contents ? *contents : x; |
| } |
| )"); |
| |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| template <typename T1, typename T2> |
| struct pair { T1 fst; T2 snd; }; |
| int target() { |
| auto [contents, x] = Make<pair<$ns::$optional<int>, int>>(); |
| return contents ? *contents : x; |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, StructuredBindingsFromTupleLikeType) { |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| namespace std { |
| template <class> struct tuple_size; |
| template <size_t, class> struct tuple_element; |
| template <class...> class tuple; |
| |
| template <class... T> |
| struct tuple_size<tuple<T...>> : integral_constant<size_t, sizeof...(T)> {}; |
| |
| template <size_t I, class... T> |
| struct tuple_element<I, tuple<T...>> { |
| using type = __type_pack_element<I, T...>; |
| }; |
| |
| template <class...> class tuple {}; |
| template <size_t I, class... T> |
| typename tuple_element<I, tuple<T...>>::type get(tuple<T...>); |
| } // namespace std |
| |
| std::tuple<$ns::$optional<const char *>, int> get_opt(); |
| void target() { |
| auto [content, ck] = get_opt(); |
| content ? *content : ""; |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, CtorInitializerNullopt) { |
| using namespace ast_matchers; |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct Target { |
| Target(): opt($ns::nullopt) { |
| opt.value(); // [[unsafe]] |
| } |
| $ns::$optional<int> opt; |
| }; |
| )", |
| cxxConstructorDecl(ofClass(hasName("Target")))); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, CtorInitializerValue) { |
| using namespace ast_matchers; |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct Target { |
| Target(): opt(3) { |
| opt.value(); |
| } |
| $ns::$optional<int> opt; |
| }; |
| )", |
| cxxConstructorDecl(ofClass(hasName("Target")))); |
| } |
| |
| // This is regression test, it shouldn't crash. |
| TEST_P(UncheckedOptionalAccessTest, Bitfield) { |
| using namespace ast_matchers; |
| ExpectDiagnosticsFor( |
| R"( |
| #include "unchecked_optional_access_test.h" |
| struct Dst { |
| unsigned int n : 1; |
| }; |
| void target() { |
| $ns::$optional<bool> v; |
| Dst d; |
| if (v.has_value()) |
| d.n = v.value(); |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, LambdaParam) { |
| ExpectDiagnosticsForLambda(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target() { |
| []($ns::$optional<int> opt) { |
| if (opt.has_value()) { |
| opt.value(); |
| } else { |
| opt.value(); // [[unsafe]] |
| } |
| }(Make<$ns::$optional<int>>()); |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, LambdaCaptureByCopy) { |
| ExpectDiagnosticsForLambda(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target($ns::$optional<int> opt) { |
| [opt]() { |
| if (opt.has_value()) { |
| opt.value(); |
| } else { |
| opt.value(); // [[unsafe]] |
| } |
| }(); |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, LambdaCaptureByReference) { |
| ExpectDiagnosticsForLambda(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target($ns::$optional<int> opt) { |
| [&opt]() { |
| if (opt.has_value()) { |
| opt.value(); |
| } else { |
| opt.value(); // [[unsafe]] |
| } |
| }(); |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, LambdaCaptureWithInitializer) { |
| ExpectDiagnosticsForLambda(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target($ns::$optional<int> opt) { |
| [opt2=opt]() { |
| if (opt2.has_value()) { |
| opt2.value(); |
| } else { |
| opt2.value(); // [[unsafe]] |
| } |
| }(); |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, LambdaCaptureByCopyImplicit) { |
| ExpectDiagnosticsForLambda(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target($ns::$optional<int> opt) { |
| [=]() { |
| if (opt.has_value()) { |
| opt.value(); |
| } else { |
| opt.value(); // [[unsafe]] |
| } |
| }(); |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, LambdaCaptureByReferenceImplicit) { |
| ExpectDiagnosticsForLambda(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target($ns::$optional<int> opt) { |
| [&]() { |
| if (opt.has_value()) { |
| opt.value(); |
| } else { |
| opt.value(); // [[unsafe]] |
| } |
| }(); |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, LambdaCaptureThis) { |
| ExpectDiagnosticsForLambda(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct Foo { |
| $ns::$optional<int> opt; |
| |
| void target() { |
| [this]() { |
| if (opt.has_value()) { |
| opt.value(); |
| } else { |
| opt.value(); // [[unsafe]] |
| } |
| }(); |
| } |
| }; |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, LambdaCaptureStateNotPropagated) { |
| // We can't propagate information from the surrounding context. |
| ExpectDiagnosticsForLambda(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| void target($ns::$optional<int> opt) { |
| if (opt.has_value()) { |
| [&opt]() { |
| opt.value(); // [[unsafe]] |
| }(); |
| } |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ClassDerivedFromOptional) { |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct Derived : public $ns::$optional<int> {}; |
| |
| void target(Derived opt) { |
| *opt; // [[unsafe]] |
| if (opt.has_value()) |
| *opt; |
| |
| // The same thing, but with a pointer receiver. |
| Derived *popt = &opt; |
| **popt; // [[unsafe]] |
| if (popt->has_value()) |
| **popt; |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ClassTemplateDerivedFromOptional) { |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| template <class T> |
| struct Derived : public $ns::$optional<T> {}; |
| |
| void target(Derived<int> opt) { |
| *opt; // [[unsafe]] |
| if (opt.has_value()) |
| *opt; |
| |
| // The same thing, but with a pointer receiver. |
| Derived<int> *popt = &opt; |
| **popt; // [[unsafe]] |
| if (popt->has_value()) |
| **popt; |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ClassDerivedPrivatelyFromOptional) { |
| // Classes that derive privately from optional can themselves still call |
| // member functions of optional. Check that we model the optional correctly |
| // in this situation. |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct Derived : private $ns::$optional<int> { |
| void Method() { |
| **this; // [[unsafe]] |
| if (this->has_value()) |
| **this; |
| } |
| }; |
| )", |
| ast_matchers::hasName("Method")); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ClassDerivedFromOptionalValueConstructor) { |
| ExpectDiagnosticsFor(R"( |
| #include "unchecked_optional_access_test.h" |
| |
| struct Derived : public $ns::$optional<int> { |
| Derived(int); |
| }; |
| |
| void target(Derived opt) { |
| *opt; // [[unsafe]] |
| opt = 1; |
| *opt; |
| } |
| )"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ConstRefAccessor) { |
| ExpectDiagnosticsFor(R"cc( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| const $ns::$optional<int>& get() const { return x; } |
| $ns::$optional<int> x; |
| }; |
| |
| void target(A& a) { |
| if (a.get().has_value()) { |
| a.get().value(); |
| } |
| } |
| )cc"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ConstRefAccessorWithModInBetween) { |
| ExpectDiagnosticsFor(R"cc( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| const $ns::$optional<int>& get() const { return x; } |
| void clear(); |
| $ns::$optional<int> x; |
| }; |
| |
| void target(A& a) { |
| if (a.get().has_value()) { |
| a.clear(); |
| a.get().value(); // [[unsafe]] |
| } |
| } |
| )cc"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ConstRefAccessorWithModReturningOptional) { |
| ExpectDiagnosticsFor(R"cc( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| const $ns::$optional<int>& get() const { return x; } |
| $ns::$optional<int> take(); |
| $ns::$optional<int> x; |
| }; |
| |
| void target(A& a) { |
| if (a.get().has_value()) { |
| $ns::$optional<int> other = a.take(); |
| a.get().value(); // [[unsafe]] |
| if (other.has_value()) { |
| other.value(); |
| } |
| } |
| } |
| )cc"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ConstRefAccessorDifferentObjects) { |
| ExpectDiagnosticsFor(R"cc( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| const $ns::$optional<int>& get() const { return x; } |
| $ns::$optional<int> x; |
| }; |
| |
| void target(A& a1, A& a2) { |
| if (a1.get().has_value()) { |
| a2.get().value(); // [[unsafe]] |
| } |
| } |
| )cc"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ConstRefAccessorLoop) { |
| ExpectDiagnosticsFor(R"cc( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| const $ns::$optional<int>& get() const { return x; } |
| $ns::$optional<int> x; |
| }; |
| |
| void target(A& a, int N) { |
| for (int i = 0; i < N; ++i) { |
| if (a.get().has_value()) { |
| a.get().value(); |
| } |
| } |
| } |
| )cc"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ConstByValueAccessor) { |
| ExpectDiagnosticsFor(R"cc( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| $ns::$optional<int> get() const { return x; } |
| $ns::$optional<int> x; |
| }; |
| |
| void target(A& a) { |
| if (a.get().has_value()) { |
| a.get().value(); |
| } |
| } |
| )cc"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ConstByValueAccessorWithModInBetween) { |
| ExpectDiagnosticsFor(R"cc( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| $ns::$optional<int> get() const { return x; } |
| void clear(); |
| $ns::$optional<int> x; |
| }; |
| |
| void target(A& a) { |
| if (a.get().has_value()) { |
| a.clear(); |
| a.get().value(); // [[unsafe]] |
| } |
| } |
| )cc"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ConstPointerAccessor) { |
| ExpectDiagnosticsFor(R"cc( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| $ns::$optional<int> x; |
| }; |
| |
| struct MyUniquePtr { |
| A* operator->() const; |
| }; |
| |
| void target(MyUniquePtr p) { |
| if (p->x) { |
| *p->x; |
| } |
| } |
| )cc", |
| /*IgnoreSmartPointerDereference=*/false); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ConstPointerAccessorWithModInBetween) { |
| ExpectDiagnosticsFor(R"cc( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| $ns::$optional<int> x; |
| }; |
| |
| struct MyUniquePtr { |
| A* operator->() const; |
| void reset(A*); |
| }; |
| |
| void target(MyUniquePtr p) { |
| if (p->x) { |
| p.reset(nullptr); |
| *p->x; // [[unsafe]] |
| } |
| } |
| )cc", |
| /*IgnoreSmartPointerDereference=*/false); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, SmartPointerAccessorMixed) { |
| ExpectDiagnosticsFor(R"cc( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| $ns::$optional<int> x; |
| }; |
| |
| namespace absl { |
| template<typename T> |
| class StatusOr { |
| public: |
| bool ok() const; |
| |
| const T& operator*() const&; |
| T& operator*() &; |
| |
| const T* operator->() const; |
| T* operator->(); |
| |
| const T& value() const; |
| T& value(); |
| }; |
| } |
| |
| void target(absl::StatusOr<A> &mut, const absl::StatusOr<A> &imm) { |
| if (!mut.ok() || !imm.ok()) |
| return; |
| |
| if (mut->x.has_value()) { |
| mut->x.value(); |
| ((*mut).x).value(); |
| (mut.value().x).value(); |
| |
| // check flagged after modifying |
| mut = imm; |
| mut->x.value(); // [[unsafe]] |
| } |
| if (imm->x.has_value()) { |
| imm->x.value(); |
| ((*imm).x).value(); |
| (imm.value().x).value(); |
| } |
| } |
| )cc", |
| /*IgnoreSmartPointerDereference=*/false); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ConstBoolAccessor) { |
| ExpectDiagnosticsFor(R"cc( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| bool isFoo() const { return f; } |
| bool f; |
| }; |
| |
| void target(A& a) { |
| $ns::$optional<int> opt; |
| if (a.isFoo()) { |
| opt = 1; |
| } |
| if (a.isFoo()) { |
| opt.value(); |
| } |
| } |
| )cc"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ConstBoolAccessorWithModInBetween) { |
| ExpectDiagnosticsFor(R"cc( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| bool isFoo() const { return f; } |
| void clear(); |
| bool f; |
| }; |
| |
| void target(A& a) { |
| $ns::$optional<int> opt; |
| if (a.isFoo()) { |
| opt = 1; |
| } |
| a.clear(); |
| if (a.isFoo()) { |
| opt.value(); // [[unsafe]] |
| } |
| } |
| )cc"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, |
| ConstRefAccessorToOptionalViaConstRefAccessorToHoldingObject) { |
| ExpectDiagnosticsFor(R"cc( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| const $ns::$optional<int>& get() const { return x; } |
| |
| $ns::$optional<int> x; |
| }; |
| |
| struct B { |
| const A& getA() const { return a; } |
| |
| A a; |
| }; |
| |
| void target(B& b) { |
| if (b.getA().get().has_value()) { |
| b.getA().get().value(); |
| } |
| } |
| )cc"); |
| } |
| |
| TEST_P( |
| UncheckedOptionalAccessTest, |
| ConstRefAccessorToOptionalViaConstRefAccessorToHoldingObjectWithoutValueCheck) { |
| ExpectDiagnosticsFor(R"cc( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| const $ns::$optional<int>& get() const { return x; } |
| |
| $ns::$optional<int> x; |
| }; |
| |
| struct B { |
| const A& getA() const { return a; } |
| |
| A a; |
| }; |
| |
| void target(B& b) { |
| b.getA().get().value(); // [[unsafe]] |
| } |
| )cc"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, |
| ConstRefToOptionalSavedAsTemporaryVariable) { |
| ExpectDiagnosticsFor(R"cc( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| const $ns::$optional<int>& get() const { return x; } |
| |
| $ns::$optional<int> x; |
| }; |
| |
| struct B { |
| const A& getA() const { return a; } |
| |
| A a; |
| }; |
| |
| void target(B& b) { |
| const auto& opt = b.getA().get(); |
| if (opt.has_value()) { |
| opt.value(); |
| } |
| } |
| )cc"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, |
| ConstRefAccessorToOptionalViaAccessorToHoldingObjectByValue) { |
| ExpectDiagnosticsFor(R"cc( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| const $ns::$optional<int>& get() const { return x; } |
| |
| $ns::$optional<int> x; |
| }; |
| |
| struct B { |
| const A copyA() const { return a; } |
| |
| A a; |
| }; |
| |
| void target(B& b) { |
| if (b.copyA().get().has_value()) { |
| b.copyA().get().value(); // [[unsafe]] |
| } |
| } |
| )cc"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, |
| ConstRefAccessorToOptionalViaNonConstRefAccessorToHoldingObject) { |
| ExpectDiagnosticsFor(R"cc( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| const $ns::$optional<int>& get() const { return x; } |
| |
| $ns::$optional<int> x; |
| }; |
| |
| struct B { |
| A& getA() { return a; } |
| |
| A a; |
| }; |
| |
| void target(B& b) { |
| if (b.getA().get().has_value()) { |
| b.getA().get().value(); // [[unsafe]] |
| } |
| } |
| )cc"); |
| } |
| |
| TEST_P( |
| UncheckedOptionalAccessTest, |
| ConstRefAccessorToOptionalViaConstRefAccessorToHoldingObjectWithModAfterCheck) { |
| ExpectDiagnosticsFor(R"cc( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| const $ns::$optional<int>& get() const { return x; } |
| |
| $ns::$optional<int> x; |
| }; |
| |
| struct B { |
| const A& getA() const { return a; } |
| |
| A& getA() { return a; } |
| |
| void clear() { a = A{}; } |
| |
| A a; |
| }; |
| |
| void target(B& b) { |
| // changing field A via non-const getter after const getter check |
| if (b.getA().get().has_value()) { |
| b.getA() = A{}; |
| b.getA().get().value(); // [[unsafe]] |
| } |
| |
| // calling non-const method which might change field A |
| if (b.getA().get().has_value()) { |
| b.clear(); |
| b.getA().get().value(); // [[unsafe]] |
| } |
| } |
| )cc"); |
| } |
| |
| TEST_P( |
| UncheckedOptionalAccessTest, |
| ConstRefAccessorToOptionalViaConstRefAccessorToHoldingObjectWithAnotherConstCallAfterCheck) { |
| ExpectDiagnosticsFor(R"cc( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| const $ns::$optional<int>& get() const { return x; } |
| |
| $ns::$optional<int> x; |
| }; |
| |
| struct B { |
| const A& getA() const { return a; } |
| |
| void callWithoutChanges() const { |
| // no-op |
| } |
| |
| A a; |
| }; |
| |
| void target(B& b) { |
| if (b.getA().get().has_value()) { |
| b.callWithoutChanges(); // calling const method which cannot change A |
| b.getA().get().value(); |
| } |
| } |
| )cc"); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, ConstPointerRefAccessor) { |
| // A crash reproducer for https://github.com/llvm/llvm-project/issues/125589 |
| // NOTE: we currently cache const ref accessors's locations. |
| // If we want to support const ref to pointers or bools, we should initialize |
| // their values. |
| ExpectDiagnosticsFor(R"cc( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| $ns::$optional<int> x; |
| }; |
| |
| struct PtrWrapper { |
| A*& getPtrRef() const; |
| void reset(A*); |
| }; |
| |
| void target(PtrWrapper p) { |
| if (p.getPtrRef()->x) { |
| *p.getPtrRef()->x; // [[unsafe]] |
| p.reset(nullptr); |
| *p.getPtrRef()->x; // [[unsafe]] |
| } |
| } |
| )cc", |
| /*IgnoreSmartPointerDereference=*/false); |
| } |
| |
| TEST_P(UncheckedOptionalAccessTest, DiagnosticsHaveRanges) { |
| ExpectDiagnosticsFor(R"cc( |
| #include "unchecked_optional_access_test.h" |
| |
| struct A { |
| $ns::$optional<int> fi; |
| }; |
| struct B { |
| $ns::$optional<A> fa; |
| }; |
| |
| void target($ns::$optional<B> opt) { |
| opt.value(); // [[unsafe:<input.cc:12:7>]] |
| if (opt) { |
| opt // [[unsafe:<input.cc:14:9, line:16:13>]] |
| -> |
| fa.value(); |
| if (opt->fa) { |
| opt->fa->fi.value(); // [[unsafe:<input.cc:18:11, col:20>]] |
| } |
| } |
| } |
| )cc"); |
| } |
| |
| // FIXME: Add support for: |
| // - constructors (copy, move) |
| // - assignment operators (default, copy, move) |
| // - invalidation (passing optional by non-const reference/pointer) |
