1 //===- UncheckedOptionalAccessModelTest.cpp -------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // FIXME: Move this to clang/unittests/Analysis/FlowSensitive/Models. 9 10 #include "clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h" 11 #include "TestingSupport.h" 12 #include "clang/AST/ASTContext.h" 13 #include "clang/ASTMatchers/ASTMatchers.h" 14 #include "clang/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.h" 15 #include "clang/Basic/SourceLocation.h" 16 #include "clang/Tooling/Tooling.h" 17 #include "llvm/ADT/DenseSet.h" 18 #include "llvm/ADT/STLExtras.h" 19 #include "llvm/Support/Error.h" 20 #include "gmock/gmock.h" 21 #include "gtest/gtest.h" 22 #include <optional> 23 #include <string> 24 #include <utility> 25 #include <vector> 26 27 using namespace clang; 28 using namespace dataflow; 29 using namespace test; 30 31 using ::testing::ContainerEq; 32 33 // FIXME: Move header definitions in separate file(s). 34 static constexpr char CSDtdDefHeader[] = R"( 35 #ifndef CSTDDEF_H 36 #define CSTDDEF_H 37 38 namespace std { 39 40 typedef decltype(sizeof(char)) size_t; 41 42 using nullptr_t = decltype(nullptr); 43 44 } // namespace std 45 46 #endif // CSTDDEF_H 47 )"; 48 49 static constexpr char StdTypeTraitsHeader[] = R"( 50 #ifndef STD_TYPE_TRAITS_H 51 #define STD_TYPE_TRAITS_H 52 53 #include "cstddef.h" 54 55 namespace std { 56 57 template <typename T, T V> 58 struct integral_constant { 59 static constexpr T value = V; 60 }; 61 62 using true_type = integral_constant<bool, true>; 63 using false_type = integral_constant<bool, false>; 64 65 template< class T > struct remove_reference {typedef T type;}; 66 template< class T > struct remove_reference<T&> {typedef T type;}; 67 template< class T > struct remove_reference<T&&> {typedef T type;}; 68 69 template <class T> 70 using remove_reference_t = typename remove_reference<T>::type; 71 72 template <class T> 73 struct remove_extent { 74 typedef T type; 75 }; 76 77 template <class T> 78 struct remove_extent<T[]> { 79 typedef T type; 80 }; 81 82 template <class T, size_t N> 83 struct remove_extent<T[N]> { 84 typedef T type; 85 }; 86 87 template <class T> 88 struct is_array : false_type {}; 89 90 template <class T> 91 struct is_array<T[]> : true_type {}; 92 93 template <class T, size_t N> 94 struct is_array<T[N]> : true_type {}; 95 96 template <class> 97 struct is_function : false_type {}; 98 99 template <class Ret, class... Args> 100 struct is_function<Ret(Args...)> : true_type {}; 101 102 namespace detail { 103 104 template <class T> 105 struct type_identity { 106 using type = T; 107 }; // or use type_identity (since C++20) 108 109 template <class T> 110 auto try_add_pointer(int) -> type_identity<typename remove_reference<T>::type*>; 111 template <class T> 112 auto try_add_pointer(...) -> type_identity<T>; 113 114 } // namespace detail 115 116 template <class T> 117 struct add_pointer : decltype(detail::try_add_pointer<T>(0)) {}; 118 119 template <bool B, class T, class F> 120 struct conditional { 121 typedef T type; 122 }; 123 124 template <class T, class F> 125 struct conditional<false, T, F> { 126 typedef F type; 127 }; 128 129 template <class T> 130 struct remove_cv { 131 typedef T type; 132 }; 133 template <class T> 134 struct remove_cv<const T> { 135 typedef T type; 136 }; 137 template <class T> 138 struct remove_cv<volatile T> { 139 typedef T type; 140 }; 141 template <class T> 142 struct remove_cv<const volatile T> { 143 typedef T type; 144 }; 145 146 template <class T> 147 using remove_cv_t = typename remove_cv<T>::type; 148 149 template <class T> 150 struct decay { 151 private: 152 typedef typename remove_reference<T>::type U; 153 154 public: 155 typedef typename conditional< 156 is_array<U>::value, typename remove_extent<U>::type*, 157 typename conditional<is_function<U>::value, typename add_pointer<U>::type, 158 typename remove_cv<U>::type>::type>::type type; 159 }; 160 161 template <bool B, class T = void> 162 struct enable_if {}; 163 164 template <class T> 165 struct enable_if<true, T> { 166 typedef T type; 167 }; 168 169 template <bool B, class T = void> 170 using enable_if_t = typename enable_if<B, T>::type; 171 172 template <class T, class U> 173 struct is_same : false_type {}; 174 175 template <class T> 176 struct is_same<T, T> : true_type {}; 177 178 template <class T> 179 struct is_void : is_same<void, typename remove_cv<T>::type> {}; 180 181 namespace detail { 182 183 template <class T> 184 auto try_add_lvalue_reference(int) -> type_identity<T&>; 185 template <class T> 186 auto try_add_lvalue_reference(...) -> type_identity<T>; 187 188 template <class T> 189 auto try_add_rvalue_reference(int) -> type_identity<T&&>; 190 template <class T> 191 auto try_add_rvalue_reference(...) -> type_identity<T>; 192 193 } // namespace detail 194 195 template <class T> 196 struct add_lvalue_reference : decltype(detail::try_add_lvalue_reference<T>(0)) { 197 }; 198 199 template <class T> 200 struct add_rvalue_reference : decltype(detail::try_add_rvalue_reference<T>(0)) { 201 }; 202 203 template <class T> 204 typename add_rvalue_reference<T>::type declval() noexcept; 205 206 namespace detail { 207 208 template <class T> 209 auto test_returnable(int) 210 -> decltype(void(static_cast<T (*)()>(nullptr)), true_type{}); 211 template <class> 212 auto test_returnable(...) -> false_type; 213 214 template <class From, class To> 215 auto test_implicitly_convertible(int) 216 -> decltype(void(declval<void (&)(To)>()(declval<From>())), true_type{}); 217 template <class, class> 218 auto test_implicitly_convertible(...) -> false_type; 219 220 } // namespace detail 221 222 template <class From, class To> 223 struct is_convertible 224 : integral_constant<bool, 225 (decltype(detail::test_returnable<To>(0))::value && 226 decltype(detail::test_implicitly_convertible<From, To>( 227 0))::value) || 228 (is_void<From>::value && is_void<To>::value)> {}; 229 230 template <class From, class To> 231 inline constexpr bool is_convertible_v = is_convertible<From, To>::value; 232 233 template <class...> 234 using void_t = void; 235 236 template <class, class T, class... Args> 237 struct is_constructible_ : false_type {}; 238 239 template <class T, class... Args> 240 struct is_constructible_<void_t<decltype(T(declval<Args>()...))>, T, Args...> 241 : true_type {}; 242 243 template <class T, class... Args> 244 using is_constructible = is_constructible_<void_t<>, T, Args...>; 245 246 template <class T, class... Args> 247 inline constexpr bool is_constructible_v = is_constructible<T, Args...>::value; 248 249 template <class _Tp> 250 struct __uncvref { 251 typedef typename remove_cv<typename remove_reference<_Tp>::type>::type type; 252 }; 253 254 template <class _Tp> 255 using __uncvref_t = typename __uncvref<_Tp>::type; 256 257 template <bool _Val> 258 using _BoolConstant = integral_constant<bool, _Val>; 259 260 template <class _Tp, class _Up> 261 using _IsSame = _BoolConstant<__is_same(_Tp, _Up)>; 262 263 template <class _Tp, class _Up> 264 using _IsNotSame = _BoolConstant<!__is_same(_Tp, _Up)>; 265 266 template <bool> 267 struct _MetaBase; 268 template <> 269 struct _MetaBase<true> { 270 template <class _Tp, class _Up> 271 using _SelectImpl = _Tp; 272 template <template <class...> class _FirstFn, template <class...> class, 273 class... _Args> 274 using _SelectApplyImpl = _FirstFn<_Args...>; 275 template <class _First, class...> 276 using _FirstImpl = _First; 277 template <class, class _Second, class...> 278 using _SecondImpl = _Second; 279 template <class _Result, class _First, class... _Rest> 280 using _OrImpl = 281 typename _MetaBase<_First::value != true && sizeof...(_Rest) != 0>:: 282 template _OrImpl<_First, _Rest...>; 283 }; 284 285 template <> 286 struct _MetaBase<false> { 287 template <class _Tp, class _Up> 288 using _SelectImpl = _Up; 289 template <template <class...> class, template <class...> class _SecondFn, 290 class... _Args> 291 using _SelectApplyImpl = _SecondFn<_Args...>; 292 template <class _Result, class...> 293 using _OrImpl = _Result; 294 }; 295 296 template <bool _Cond, class _IfRes, class _ElseRes> 297 using _If = typename _MetaBase<_Cond>::template _SelectImpl<_IfRes, _ElseRes>; 298 299 template <class... _Rest> 300 using _Or = typename _MetaBase<sizeof...(_Rest) != 301 0>::template _OrImpl<false_type, _Rest...>; 302 303 template <bool _Bp, class _Tp = void> 304 using __enable_if_t = typename enable_if<_Bp, _Tp>::type; 305 306 template <class...> 307 using __expand_to_true = true_type; 308 template <class... _Pred> 309 __expand_to_true<__enable_if_t<_Pred::value>...> __and_helper(int); 310 template <class...> 311 false_type __and_helper(...); 312 template <class... _Pred> 313 using _And = decltype(__and_helper<_Pred...>(0)); 314 315 template <class _Pred> 316 struct _Not : _BoolConstant<!_Pred::value> {}; 317 318 struct __check_tuple_constructor_fail { 319 static constexpr bool __enable_explicit_default() { return false; } 320 static constexpr bool __enable_implicit_default() { return false; } 321 template <class...> 322 static constexpr bool __enable_explicit() { 323 return false; 324 } 325 template <class...> 326 static constexpr bool __enable_implicit() { 327 return false; 328 } 329 }; 330 331 template <typename, typename _Tp> 332 struct __select_2nd { 333 typedef _Tp type; 334 }; 335 template <class _Tp, class _Arg> 336 typename __select_2nd<decltype((declval<_Tp>() = declval<_Arg>())), 337 true_type>::type 338 __is_assignable_test(int); 339 template <class, class> 340 false_type __is_assignable_test(...); 341 template <class _Tp, class _Arg, 342 bool = is_void<_Tp>::value || is_void<_Arg>::value> 343 struct __is_assignable_imp 344 : public decltype((__is_assignable_test<_Tp, _Arg>(0))) {}; 345 template <class _Tp, class _Arg> 346 struct __is_assignable_imp<_Tp, _Arg, true> : public false_type {}; 347 template <class _Tp, class _Arg> 348 struct is_assignable : public __is_assignable_imp<_Tp, _Arg> {}; 349 350 template <class _Tp> 351 struct __libcpp_is_integral : public false_type {}; 352 template <> 353 struct __libcpp_is_integral<bool> : public true_type {}; 354 template <> 355 struct __libcpp_is_integral<char> : public true_type {}; 356 template <> 357 struct __libcpp_is_integral<signed char> : public true_type {}; 358 template <> 359 struct __libcpp_is_integral<unsigned char> : public true_type {}; 360 template <> 361 struct __libcpp_is_integral<wchar_t> : public true_type {}; 362 template <> 363 struct __libcpp_is_integral<short> : public true_type {}; // NOLINT 364 template <> 365 struct __libcpp_is_integral<unsigned short> : public true_type {}; // NOLINT 366 template <> 367 struct __libcpp_is_integral<int> : public true_type {}; 368 template <> 369 struct __libcpp_is_integral<unsigned int> : public true_type {}; 370 template <> 371 struct __libcpp_is_integral<long> : public true_type {}; // NOLINT 372 template <> 373 struct __libcpp_is_integral<unsigned long> : public true_type {}; // NOLINT 374 template <> 375 struct __libcpp_is_integral<long long> : public true_type {}; // NOLINT 376 template <> // NOLINTNEXTLINE 377 struct __libcpp_is_integral<unsigned long long> : public true_type {}; 378 template <class _Tp> 379 struct is_integral 380 : public __libcpp_is_integral<typename remove_cv<_Tp>::type> {}; 381 382 template <class _Tp> 383 struct __libcpp_is_floating_point : public false_type {}; 384 template <> 385 struct __libcpp_is_floating_point<float> : public true_type {}; 386 template <> 387 struct __libcpp_is_floating_point<double> : public true_type {}; 388 template <> 389 struct __libcpp_is_floating_point<long double> : public true_type {}; 390 template <class _Tp> 391 struct is_floating_point 392 : public __libcpp_is_floating_point<typename remove_cv<_Tp>::type> {}; 393 394 template <class _Tp> 395 struct is_arithmetic 396 : public integral_constant<bool, is_integral<_Tp>::value || 397 is_floating_point<_Tp>::value> {}; 398 399 template <class _Tp> 400 struct __libcpp_is_pointer : public false_type {}; 401 template <class _Tp> 402 struct __libcpp_is_pointer<_Tp*> : public true_type {}; 403 template <class _Tp> 404 struct is_pointer : public __libcpp_is_pointer<typename remove_cv<_Tp>::type> { 405 }; 406 407 template <class _Tp> 408 struct __libcpp_is_member_pointer : public false_type {}; 409 template <class _Tp, class _Up> 410 struct __libcpp_is_member_pointer<_Tp _Up::*> : public true_type {}; 411 template <class _Tp> 412 struct is_member_pointer 413 : public __libcpp_is_member_pointer<typename remove_cv<_Tp>::type> {}; 414 415 template <class _Tp> 416 struct __libcpp_union : public false_type {}; 417 template <class _Tp> 418 struct is_union : public __libcpp_union<typename remove_cv<_Tp>::type> {}; 419 420 template <class T> 421 struct is_reference : false_type {}; 422 template <class T> 423 struct is_reference<T&> : true_type {}; 424 template <class T> 425 struct is_reference<T&&> : true_type {}; 426 427 template <class T> 428 inline constexpr bool is_reference_v = is_reference<T>::value; 429 430 struct __two { 431 char __lx[2]; 432 }; 433 434 namespace __is_class_imp { 435 template <class _Tp> 436 char __test(int _Tp::*); 437 template <class _Tp> 438 __two __test(...); 439 } // namespace __is_class_imp 440 template <class _Tp> 441 struct is_class 442 : public integral_constant<bool, 443 sizeof(__is_class_imp::__test<_Tp>(0)) == 1 && 444 !is_union<_Tp>::value> {}; 445 446 template <class _Tp> 447 struct __is_nullptr_t_impl : public false_type {}; 448 template <> 449 struct __is_nullptr_t_impl<nullptr_t> : public true_type {}; 450 template <class _Tp> 451 struct __is_nullptr_t 452 : public __is_nullptr_t_impl<typename remove_cv<_Tp>::type> {}; 453 template <class _Tp> 454 struct is_null_pointer 455 : public __is_nullptr_t_impl<typename remove_cv<_Tp>::type> {}; 456 457 template <class _Tp> 458 struct is_enum 459 : public integral_constant< 460 bool, !is_void<_Tp>::value && !is_integral<_Tp>::value && 461 !is_floating_point<_Tp>::value && !is_array<_Tp>::value && 462 !is_pointer<_Tp>::value && !is_reference<_Tp>::value && 463 !is_member_pointer<_Tp>::value && !is_union<_Tp>::value && 464 !is_class<_Tp>::value && !is_function<_Tp>::value> {}; 465 466 template <class _Tp> 467 struct is_scalar 468 : public integral_constant< 469 bool, is_arithmetic<_Tp>::value || is_member_pointer<_Tp>::value || 470 is_pointer<_Tp>::value || __is_nullptr_t<_Tp>::value || 471 is_enum<_Tp>::value> {}; 472 template <> 473 struct is_scalar<nullptr_t> : public true_type {}; 474 475 } // namespace std 476 477 #endif // STD_TYPE_TRAITS_H 478 )"; 479 480 static constexpr char AbslTypeTraitsHeader[] = R"( 481 #ifndef ABSL_TYPE_TRAITS_H 482 #define ABSL_TYPE_TRAITS_H 483 484 #include "std_type_traits.h" 485 486 namespace absl { 487 488 template <typename... Ts> 489 struct conjunction : std::true_type {}; 490 491 template <typename T, typename... Ts> 492 struct conjunction<T, Ts...> 493 : std::conditional<T::value, conjunction<Ts...>, T>::type {}; 494 495 template <typename T> 496 struct conjunction<T> : T {}; 497 498 template <typename T> 499 struct negation : std::integral_constant<bool, !T::value> {}; 500 501 template <bool B, typename T = void> 502 using enable_if_t = typename std::enable_if<B, T>::type; 503 504 } // namespace absl 505 506 #endif // ABSL_TYPE_TRAITS_H 507 )"; 508 509 static constexpr char StdStringHeader[] = R"( 510 #ifndef STRING_H 511 #define STRING_H 512 513 namespace std { 514 515 struct string { 516 string(const char*); 517 ~string(); 518 bool empty(); 519 }; 520 bool operator!=(const string &LHS, const char *RHS); 521 522 } // namespace std 523 524 #endif // STRING_H 525 )"; 526 527 static constexpr char StdUtilityHeader[] = R"( 528 #ifndef UTILITY_H 529 #define UTILITY_H 530 531 #include "std_type_traits.h" 532 533 namespace std { 534 535 template <typename T> 536 constexpr remove_reference_t<T>&& move(T&& x); 537 538 template <typename T> 539 void swap(T& a, T& b) noexcept; 540 541 } // namespace std 542 543 #endif // UTILITY_H 544 )"; 545 546 static constexpr char StdInitializerListHeader[] = R"( 547 #ifndef INITIALIZER_LIST_H 548 #define INITIALIZER_LIST_H 549 550 namespace std { 551 552 template <typename T> 553 class initializer_list { 554 public: 555 initializer_list() noexcept; 556 }; 557 558 } // namespace std 559 560 #endif // INITIALIZER_LIST_H 561 )"; 562 563 static constexpr char StdOptionalHeader[] = R"( 564 #include "std_initializer_list.h" 565 #include "std_type_traits.h" 566 #include "std_utility.h" 567 568 namespace std { 569 570 struct in_place_t {}; 571 constexpr in_place_t in_place; 572 573 struct nullopt_t { 574 constexpr explicit nullopt_t() {} 575 }; 576 constexpr nullopt_t nullopt; 577 578 template <class _Tp> 579 struct __optional_destruct_base { 580 constexpr void reset() noexcept; 581 }; 582 583 template <class _Tp> 584 struct __optional_storage_base : __optional_destruct_base<_Tp> { 585 constexpr bool has_value() const noexcept; 586 }; 587 588 template <typename _Tp> 589 class optional : private __optional_storage_base<_Tp> { 590 using __base = __optional_storage_base<_Tp>; 591 592 public: 593 using value_type = _Tp; 594 595 private: 596 struct _CheckOptionalArgsConstructor { 597 template <class _Up> 598 static constexpr bool __enable_implicit() { 599 return is_constructible_v<_Tp, _Up&&> && is_convertible_v<_Up&&, _Tp>; 600 } 601 602 template <class _Up> 603 static constexpr bool __enable_explicit() { 604 return is_constructible_v<_Tp, _Up&&> && !is_convertible_v<_Up&&, _Tp>; 605 } 606 }; 607 template <class _Up> 608 using _CheckOptionalArgsCtor = 609 _If<_IsNotSame<__uncvref_t<_Up>, in_place_t>::value && 610 _IsNotSame<__uncvref_t<_Up>, optional>::value, 611 _CheckOptionalArgsConstructor, __check_tuple_constructor_fail>; 612 template <class _QualUp> 613 struct _CheckOptionalLikeConstructor { 614 template <class _Up, class _Opt = optional<_Up>> 615 using __check_constructible_from_opt = 616 _Or<is_constructible<_Tp, _Opt&>, is_constructible<_Tp, _Opt const&>, 617 is_constructible<_Tp, _Opt&&>, is_constructible<_Tp, _Opt const&&>, 618 is_convertible<_Opt&, _Tp>, is_convertible<_Opt const&, _Tp>, 619 is_convertible<_Opt&&, _Tp>, is_convertible<_Opt const&&, _Tp>>; 620 template <class _Up, class _QUp = _QualUp> 621 static constexpr bool __enable_implicit() { 622 return is_convertible<_QUp, _Tp>::value && 623 !__check_constructible_from_opt<_Up>::value; 624 } 625 template <class _Up, class _QUp = _QualUp> 626 static constexpr bool __enable_explicit() { 627 return !is_convertible<_QUp, _Tp>::value && 628 !__check_constructible_from_opt<_Up>::value; 629 } 630 }; 631 632 template <class _Up, class _QualUp> 633 using _CheckOptionalLikeCtor = 634 _If<_And<_IsNotSame<_Up, _Tp>, is_constructible<_Tp, _QualUp>>::value, 635 _CheckOptionalLikeConstructor<_QualUp>, 636 __check_tuple_constructor_fail>; 637 638 639 template <class _Up, class _QualUp> 640 using _CheckOptionalLikeAssign = _If< 641 _And< 642 _IsNotSame<_Up, _Tp>, 643 is_constructible<_Tp, _QualUp>, 644 is_assignable<_Tp&, _QualUp> 645 >::value, 646 _CheckOptionalLikeConstructor<_QualUp>, 647 __check_tuple_constructor_fail 648 >; 649 650 public: 651 constexpr optional() noexcept {} 652 constexpr optional(const optional&) = default; 653 constexpr optional(optional&&) = default; 654 constexpr optional(nullopt_t) noexcept {} 655 656 template < 657 class _InPlaceT, class... _Args, 658 class = enable_if_t<_And<_IsSame<_InPlaceT, in_place_t>, 659 is_constructible<value_type, _Args...>>::value>> 660 constexpr explicit optional(_InPlaceT, _Args&&... __args); 661 662 template <class _Up, class... _Args, 663 class = enable_if_t<is_constructible_v< 664 value_type, initializer_list<_Up>&, _Args...>>> 665 constexpr explicit optional(in_place_t, initializer_list<_Up> __il, 666 _Args&&... __args); 667 668 template < 669 class _Up = value_type, 670 enable_if_t<_CheckOptionalArgsCtor<_Up>::template __enable_implicit<_Up>(), 671 int> = 0> 672 constexpr optional(_Up&& __v); 673 674 template < 675 class _Up, 676 enable_if_t<_CheckOptionalArgsCtor<_Up>::template __enable_explicit<_Up>(), 677 int> = 0> 678 constexpr explicit optional(_Up&& __v); 679 680 template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up const&>:: 681 template __enable_implicit<_Up>(), 682 int> = 0> 683 constexpr optional(const optional<_Up>& __v); 684 685 template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up const&>:: 686 template __enable_explicit<_Up>(), 687 int> = 0> 688 constexpr explicit optional(const optional<_Up>& __v); 689 690 template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>:: 691 template __enable_implicit<_Up>(), 692 int> = 0> 693 constexpr optional(optional<_Up>&& __v); 694 695 template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>:: 696 template __enable_explicit<_Up>(), 697 int> = 0> 698 constexpr explicit optional(optional<_Up>&& __v); 699 700 constexpr optional& operator=(nullopt_t) noexcept; 701 702 optional& operator=(const optional&); 703 704 optional& operator=(optional&&); 705 706 template <class _Up = value_type, 707 class = enable_if_t<_And<_IsNotSame<__uncvref_t<_Up>, optional>, 708 _Or<_IsNotSame<__uncvref_t<_Up>, value_type>, 709 _Not<is_scalar<value_type>>>, 710 is_constructible<value_type, _Up>, 711 is_assignable<value_type&, _Up>>::value>> 712 constexpr optional& operator=(_Up&& __v); 713 714 template <class _Up, enable_if_t<_CheckOptionalLikeAssign<_Up, _Up const&>:: 715 template __enable_assign<_Up>(), 716 int> = 0> 717 constexpr optional& operator=(const optional<_Up>& __v); 718 719 template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>:: 720 template __enable_assign<_Up>(), 721 int> = 0> 722 constexpr optional& operator=(optional<_Up>&& __v); 723 724 const _Tp& operator*() const&; 725 _Tp& operator*() &; 726 const _Tp&& operator*() const&&; 727 _Tp&& operator*() &&; 728 729 const _Tp* operator->() const; 730 _Tp* operator->(); 731 732 const _Tp& value() const&; 733 _Tp& value() &; 734 const _Tp&& value() const&&; 735 _Tp&& value() &&; 736 737 template <typename U> 738 constexpr _Tp value_or(U&& v) const&; 739 template <typename U> 740 _Tp value_or(U&& v) &&; 741 742 template <typename... Args> 743 _Tp& emplace(Args&&... args); 744 745 template <typename U, typename... Args> 746 _Tp& emplace(std::initializer_list<U> ilist, Args&&... args); 747 748 using __base::reset; 749 750 constexpr explicit operator bool() const noexcept; 751 using __base::has_value; 752 753 constexpr void swap(optional& __opt) noexcept; 754 }; 755 756 template <typename T> 757 constexpr optional<typename std::decay<T>::type> make_optional(T&& v); 758 759 template <typename T, typename... Args> 760 constexpr optional<T> make_optional(Args&&... args); 761 762 template <typename T, typename U, typename... Args> 763 constexpr optional<T> make_optional(std::initializer_list<U> il, 764 Args&&... args); 765 766 template <typename T, typename U> 767 constexpr bool operator==(const optional<T> &lhs, const optional<U> &rhs); 768 template <typename T, typename U> 769 constexpr bool operator!=(const optional<T> &lhs, const optional<U> &rhs); 770 771 template <typename T> 772 constexpr bool operator==(const optional<T> &opt, nullopt_t); 773 template <typename T> 774 constexpr bool operator==(nullopt_t, const optional<T> &opt); 775 template <typename T> 776 constexpr bool operator!=(const optional<T> &opt, nullopt_t); 777 template <typename T> 778 constexpr bool operator!=(nullopt_t, const optional<T> &opt); 779 780 template <typename T, typename U> 781 constexpr bool operator==(const optional<T> &opt, const U &value); 782 template <typename T, typename U> 783 constexpr bool operator==(const T &value, const optional<U> &opt); 784 template <typename T, typename U> 785 constexpr bool operator!=(const optional<T> &opt, const U &value); 786 template <typename T, typename U> 787 constexpr bool operator!=(const T &value, const optional<U> &opt); 788 789 } // namespace std 790 )"; 791 792 static constexpr char AbslOptionalHeader[] = R"( 793 #include "absl_type_traits.h" 794 #include "std_initializer_list.h" 795 #include "std_type_traits.h" 796 #include "std_utility.h" 797 798 namespace absl { 799 800 struct nullopt_t { 801 constexpr explicit nullopt_t() {} 802 }; 803 constexpr nullopt_t nullopt; 804 805 struct in_place_t {}; 806 constexpr in_place_t in_place; 807 808 template <typename T> 809 class optional; 810 811 namespace optional_internal { 812 813 template <typename T, typename U> 814 struct is_constructible_convertible_from_optional 815 : std::integral_constant< 816 bool, std::is_constructible<T, optional<U>&>::value || 817 std::is_constructible<T, optional<U>&&>::value || 818 std::is_constructible<T, const optional<U>&>::value || 819 std::is_constructible<T, const optional<U>&&>::value || 820 std::is_convertible<optional<U>&, T>::value || 821 std::is_convertible<optional<U>&&, T>::value || 822 std::is_convertible<const optional<U>&, T>::value || 823 std::is_convertible<const optional<U>&&, T>::value> {}; 824 825 template <typename T, typename U> 826 struct is_constructible_convertible_assignable_from_optional 827 : std::integral_constant< 828 bool, is_constructible_convertible_from_optional<T, U>::value || 829 std::is_assignable<T&, optional<U>&>::value || 830 std::is_assignable<T&, optional<U>&&>::value || 831 std::is_assignable<T&, const optional<U>&>::value || 832 std::is_assignable<T&, const optional<U>&&>::value> {}; 833 834 } // namespace optional_internal 835 836 template <typename T> 837 class optional { 838 public: 839 constexpr optional() noexcept; 840 841 constexpr optional(nullopt_t) noexcept; 842 843 optional(const optional&) = default; 844 845 optional(optional&&) = default; 846 847 template <typename InPlaceT, typename... Args, 848 absl::enable_if_t<absl::conjunction< 849 std::is_same<InPlaceT, in_place_t>, 850 std::is_constructible<T, Args&&...>>::value>* = nullptr> 851 constexpr explicit optional(InPlaceT, Args&&... args); 852 853 template <typename U, typename... Args, 854 typename = typename std::enable_if<std::is_constructible< 855 T, std::initializer_list<U>&, Args&&...>::value>::type> 856 constexpr explicit optional(in_place_t, std::initializer_list<U> il, 857 Args&&... args); 858 859 template < 860 typename U = T, 861 typename std::enable_if< 862 absl::conjunction<absl::negation<std::is_same< 863 in_place_t, typename std::decay<U>::type>>, 864 absl::negation<std::is_same< 865 optional<T>, typename std::decay<U>::type>>, 866 std::is_convertible<U&&, T>, 867 std::is_constructible<T, U&&>>::value, 868 bool>::type = false> 869 constexpr optional(U&& v); 870 871 template < 872 typename U = T, 873 typename std::enable_if< 874 absl::conjunction<absl::negation<std::is_same< 875 in_place_t, typename std::decay<U>::type>>, 876 absl::negation<std::is_same< 877 optional<T>, typename std::decay<U>::type>>, 878 absl::negation<std::is_convertible<U&&, T>>, 879 std::is_constructible<T, U&&>>::value, 880 bool>::type = false> 881 explicit constexpr optional(U&& v); 882 883 template <typename U, 884 typename std::enable_if< 885 absl::conjunction< 886 absl::negation<std::is_same<T, U>>, 887 std::is_constructible<T, const U&>, 888 absl::negation< 889 optional_internal:: 890 is_constructible_convertible_from_optional<T, U>>, 891 std::is_convertible<const U&, T>>::value, 892 bool>::type = false> 893 optional(const optional<U>& rhs); 894 895 template <typename U, 896 typename std::enable_if< 897 absl::conjunction< 898 absl::negation<std::is_same<T, U>>, 899 std::is_constructible<T, const U&>, 900 absl::negation< 901 optional_internal:: 902 is_constructible_convertible_from_optional<T, U>>, 903 absl::negation<std::is_convertible<const U&, T>>>::value, 904 bool>::type = false> 905 explicit optional(const optional<U>& rhs); 906 907 template < 908 typename U, 909 typename std::enable_if< 910 absl::conjunction< 911 absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>, 912 absl::negation< 913 optional_internal::is_constructible_convertible_from_optional< 914 T, U>>, 915 std::is_convertible<U&&, T>>::value, 916 bool>::type = false> 917 optional(optional<U>&& rhs); 918 919 template < 920 typename U, 921 typename std::enable_if< 922 absl::conjunction< 923 absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>, 924 absl::negation< 925 optional_internal::is_constructible_convertible_from_optional< 926 T, U>>, 927 absl::negation<std::is_convertible<U&&, T>>>::value, 928 bool>::type = false> 929 explicit optional(optional<U>&& rhs); 930 931 optional& operator=(nullopt_t) noexcept; 932 933 optional& operator=(const optional& src); 934 935 optional& operator=(optional&& src); 936 937 template < 938 typename U = T, 939 typename = typename std::enable_if<absl::conjunction< 940 absl::negation< 941 std::is_same<optional<T>, typename std::decay<U>::type>>, 942 absl::negation< 943 absl::conjunction<std::is_scalar<T>, 944 std::is_same<T, typename std::decay<U>::type>>>, 945 std::is_constructible<T, U>, std::is_assignable<T&, U>>::value>::type> 946 optional& operator=(U&& v); 947 948 template < 949 typename U, 950 typename = typename std::enable_if<absl::conjunction< 951 absl::negation<std::is_same<T, U>>, 952 std::is_constructible<T, const U&>, std::is_assignable<T&, const U&>, 953 absl::negation< 954 optional_internal:: 955 is_constructible_convertible_assignable_from_optional< 956 T, U>>>::value>::type> 957 optional& operator=(const optional<U>& rhs); 958 959 template <typename U, 960 typename = typename std::enable_if<absl::conjunction< 961 absl::negation<std::is_same<T, U>>, std::is_constructible<T, U>, 962 std::is_assignable<T&, U>, 963 absl::negation< 964 optional_internal:: 965 is_constructible_convertible_assignable_from_optional< 966 T, U>>>::value>::type> 967 optional& operator=(optional<U>&& rhs); 968 969 const T& operator*() const&; 970 T& operator*() &; 971 const T&& operator*() const&&; 972 T&& operator*() &&; 973 974 const T* operator->() const; 975 T* operator->(); 976 977 const T& value() const&; 978 T& value() &; 979 const T&& value() const&&; 980 T&& value() &&; 981 982 template <typename U> 983 constexpr T value_or(U&& v) const&; 984 template <typename U> 985 T value_or(U&& v) &&; 986 987 template <typename... Args> 988 T& emplace(Args&&... args); 989 990 template <typename U, typename... Args> 991 T& emplace(std::initializer_list<U> ilist, Args&&... args); 992 993 void reset() noexcept; 994 995 constexpr explicit operator bool() const noexcept; 996 constexpr bool has_value() const noexcept; 997 998 void swap(optional& rhs) noexcept; 999 }; 1000 1001 template <typename T> 1002 constexpr optional<typename std::decay<T>::type> make_optional(T&& v); 1003 1004 template <typename T, typename... Args> 1005 constexpr optional<T> make_optional(Args&&... args); 1006 1007 template <typename T, typename U, typename... Args> 1008 constexpr optional<T> make_optional(std::initializer_list<U> il, 1009 Args&&... args); 1010 1011 template <typename T, typename U> 1012 constexpr bool operator==(const optional<T> &lhs, const optional<U> &rhs); 1013 template <typename T, typename U> 1014 constexpr bool operator!=(const optional<T> &lhs, const optional<U> &rhs); 1015 1016 template <typename T> 1017 constexpr bool operator==(const optional<T> &opt, nullopt_t); 1018 template <typename T> 1019 constexpr bool operator==(nullopt_t, const optional<T> &opt); 1020 template <typename T> 1021 constexpr bool operator!=(const optional<T> &opt, nullopt_t); 1022 template <typename T> 1023 constexpr bool operator!=(nullopt_t, const optional<T> &opt); 1024 1025 template <typename T, typename U> 1026 constexpr bool operator==(const optional<T> &opt, const U &value); 1027 template <typename T, typename U> 1028 constexpr bool operator==(const T &value, const optional<U> &opt); 1029 template <typename T, typename U> 1030 constexpr bool operator!=(const optional<T> &opt, const U &value); 1031 template <typename T, typename U> 1032 constexpr bool operator!=(const T &value, const optional<U> &opt); 1033 1034 } // namespace absl 1035 )"; 1036 1037 static constexpr char BaseOptionalHeader[] = R"( 1038 #include "std_initializer_list.h" 1039 #include "std_type_traits.h" 1040 #include "std_utility.h" 1041 1042 namespace base { 1043 1044 struct in_place_t {}; 1045 constexpr in_place_t in_place; 1046 1047 struct nullopt_t { 1048 constexpr explicit nullopt_t() {} 1049 }; 1050 constexpr nullopt_t nullopt; 1051 1052 template <typename T> 1053 class Optional; 1054 1055 namespace internal { 1056 1057 template <typename T> 1058 using RemoveCvRefT = std::remove_cv_t<std::remove_reference_t<T>>; 1059 1060 template <typename T, typename U> 1061 struct IsConvertibleFromOptional 1062 : std::integral_constant< 1063 bool, std::is_constructible<T, Optional<U>&>::value || 1064 std::is_constructible<T, const Optional<U>&>::value || 1065 std::is_constructible<T, Optional<U>&&>::value || 1066 std::is_constructible<T, const Optional<U>&&>::value || 1067 std::is_convertible<Optional<U>&, T>::value || 1068 std::is_convertible<const Optional<U>&, T>::value || 1069 std::is_convertible<Optional<U>&&, T>::value || 1070 std::is_convertible<const Optional<U>&&, T>::value> {}; 1071 1072 template <typename T, typename U> 1073 struct IsAssignableFromOptional 1074 : std::integral_constant< 1075 bool, IsConvertibleFromOptional<T, U>::value || 1076 std::is_assignable<T&, Optional<U>&>::value || 1077 std::is_assignable<T&, const Optional<U>&>::value || 1078 std::is_assignable<T&, Optional<U>&&>::value || 1079 std::is_assignable<T&, const Optional<U>&&>::value> {}; 1080 1081 } // namespace internal 1082 1083 template <typename T> 1084 class Optional { 1085 public: 1086 using value_type = T; 1087 1088 constexpr Optional() = default; 1089 constexpr Optional(const Optional& other) noexcept = default; 1090 constexpr Optional(Optional&& other) noexcept = default; 1091 1092 constexpr Optional(nullopt_t); 1093 1094 template <typename U, 1095 typename std::enable_if< 1096 std::is_constructible<T, const U&>::value && 1097 !internal::IsConvertibleFromOptional<T, U>::value && 1098 std::is_convertible<const U&, T>::value, 1099 bool>::type = false> 1100 Optional(const Optional<U>& other) noexcept; 1101 1102 template <typename U, 1103 typename std::enable_if< 1104 std::is_constructible<T, const U&>::value && 1105 !internal::IsConvertibleFromOptional<T, U>::value && 1106 !std::is_convertible<const U&, T>::value, 1107 bool>::type = false> 1108 explicit Optional(const Optional<U>& other) noexcept; 1109 1110 template <typename U, 1111 typename std::enable_if< 1112 std::is_constructible<T, U&&>::value && 1113 !internal::IsConvertibleFromOptional<T, U>::value && 1114 std::is_convertible<U&&, T>::value, 1115 bool>::type = false> 1116 Optional(Optional<U>&& other) noexcept; 1117 1118 template <typename U, 1119 typename std::enable_if< 1120 std::is_constructible<T, U&&>::value && 1121 !internal::IsConvertibleFromOptional<T, U>::value && 1122 !std::is_convertible<U&&, T>::value, 1123 bool>::type = false> 1124 explicit Optional(Optional<U>&& other) noexcept; 1125 1126 template <class... Args> 1127 constexpr explicit Optional(in_place_t, Args&&... args); 1128 1129 template <class U, class... Args, 1130 class = typename std::enable_if<std::is_constructible< 1131 value_type, std::initializer_list<U>&, Args...>::value>::type> 1132 constexpr explicit Optional(in_place_t, std::initializer_list<U> il, 1133 Args&&... args); 1134 1135 template < 1136 typename U = value_type, 1137 typename std::enable_if< 1138 std::is_constructible<T, U&&>::value && 1139 !std::is_same<internal::RemoveCvRefT<U>, in_place_t>::value && 1140 !std::is_same<internal::RemoveCvRefT<U>, Optional<T>>::value && 1141 std::is_convertible<U&&, T>::value, 1142 bool>::type = false> 1143 constexpr Optional(U&& value); 1144 1145 template < 1146 typename U = value_type, 1147 typename std::enable_if< 1148 std::is_constructible<T, U&&>::value && 1149 !std::is_same<internal::RemoveCvRefT<U>, in_place_t>::value && 1150 !std::is_same<internal::RemoveCvRefT<U>, Optional<T>>::value && 1151 !std::is_convertible<U&&, T>::value, 1152 bool>::type = false> 1153 constexpr explicit Optional(U&& value); 1154 1155 Optional& operator=(const Optional& other) noexcept; 1156 1157 Optional& operator=(Optional&& other) noexcept; 1158 1159 Optional& operator=(nullopt_t); 1160 1161 template <typename U> 1162 typename std::enable_if< 1163 !std::is_same<internal::RemoveCvRefT<U>, Optional<T>>::value && 1164 std::is_constructible<T, U>::value && 1165 std::is_assignable<T&, U>::value && 1166 (!std::is_scalar<T>::value || 1167 !std::is_same<typename std::decay<U>::type, T>::value), 1168 Optional&>::type 1169 operator=(U&& value) noexcept; 1170 1171 template <typename U> 1172 typename std::enable_if<!internal::IsAssignableFromOptional<T, U>::value && 1173 std::is_constructible<T, const U&>::value && 1174 std::is_assignable<T&, const U&>::value, 1175 Optional&>::type 1176 operator=(const Optional<U>& other) noexcept; 1177 1178 template <typename U> 1179 typename std::enable_if<!internal::IsAssignableFromOptional<T, U>::value && 1180 std::is_constructible<T, U>::value && 1181 std::is_assignable<T&, U>::value, 1182 Optional&>::type 1183 operator=(Optional<U>&& other) noexcept; 1184 1185 const T& operator*() const&; 1186 T& operator*() &; 1187 const T&& operator*() const&&; 1188 T&& operator*() &&; 1189 1190 const T* operator->() const; 1191 T* operator->(); 1192 1193 const T& value() const&; 1194 T& value() &; 1195 const T&& value() const&&; 1196 T&& value() &&; 1197 1198 template <typename U> 1199 constexpr T value_or(U&& v) const&; 1200 template <typename U> 1201 T value_or(U&& v) &&; 1202 1203 template <typename... Args> 1204 T& emplace(Args&&... args); 1205 1206 template <typename U, typename... Args> 1207 T& emplace(std::initializer_list<U> ilist, Args&&... args); 1208 1209 void reset() noexcept; 1210 1211 constexpr explicit operator bool() const noexcept; 1212 constexpr bool has_value() const noexcept; 1213 1214 void swap(Optional& other); 1215 }; 1216 1217 template <typename T> 1218 constexpr Optional<typename std::decay<T>::type> make_optional(T&& v); 1219 1220 template <typename T, typename... Args> 1221 constexpr Optional<T> make_optional(Args&&... args); 1222 1223 template <typename T, typename U, typename... Args> 1224 constexpr Optional<T> make_optional(std::initializer_list<U> il, 1225 Args&&... args); 1226 1227 template <typename T, typename U> 1228 constexpr bool operator==(const Optional<T> &lhs, const Optional<U> &rhs); 1229 template <typename T, typename U> 1230 constexpr bool operator!=(const Optional<T> &lhs, const Optional<U> &rhs); 1231 1232 template <typename T> 1233 constexpr bool operator==(const Optional<T> &opt, nullopt_t); 1234 template <typename T> 1235 constexpr bool operator==(nullopt_t, const Optional<T> &opt); 1236 template <typename T> 1237 constexpr bool operator!=(const Optional<T> &opt, nullopt_t); 1238 template <typename T> 1239 constexpr bool operator!=(nullopt_t, const Optional<T> &opt); 1240 1241 template <typename T, typename U> 1242 constexpr bool operator==(const Optional<T> &opt, const U &value); 1243 template <typename T, typename U> 1244 constexpr bool operator==(const T &value, const Optional<U> &opt); 1245 template <typename T, typename U> 1246 constexpr bool operator!=(const Optional<T> &opt, const U &value); 1247 template <typename T, typename U> 1248 constexpr bool operator!=(const T &value, const Optional<U> &opt); 1249 1250 } // namespace base 1251 )"; 1252 1253 /// Replaces all occurrences of `Pattern` in `S` with `Replacement`. 1254 static void ReplaceAllOccurrences(std::string &S, const std::string &Pattern, 1255 const std::string &Replacement) { 1256 size_t Pos = 0; 1257 while (true) { 1258 Pos = S.find(Pattern, Pos); 1259 if (Pos == std::string::npos) 1260 break; 1261 S.replace(Pos, Pattern.size(), Replacement); 1262 } 1263 } 1264 1265 struct OptionalTypeIdentifier { 1266 std::string NamespaceName; 1267 std::string TypeName; 1268 }; 1269 1270 class UncheckedOptionalAccessTest 1271 : public ::testing::TestWithParam<OptionalTypeIdentifier> { 1272 protected: 1273 void ExpectDiagnosticsFor(std::string SourceCode) { 1274 ExpectDiagnosticsFor(SourceCode, ast_matchers::hasName("target")); 1275 } 1276 1277 template <typename FuncDeclMatcher> 1278 void ExpectDiagnosticsFor(std::string SourceCode, 1279 FuncDeclMatcher FuncMatcher) { 1280 ReplaceAllOccurrences(SourceCode, "$ns", GetParam().NamespaceName); 1281 ReplaceAllOccurrences(SourceCode, "$optional", GetParam().TypeName); 1282 1283 std::vector<std::pair<std::string, std::string>> Headers; 1284 Headers.emplace_back("cstddef.h", CSDtdDefHeader); 1285 Headers.emplace_back("std_initializer_list.h", StdInitializerListHeader); 1286 Headers.emplace_back("std_string.h", StdStringHeader); 1287 Headers.emplace_back("std_type_traits.h", StdTypeTraitsHeader); 1288 Headers.emplace_back("std_utility.h", StdUtilityHeader); 1289 Headers.emplace_back("std_optional.h", StdOptionalHeader); 1290 Headers.emplace_back("absl_type_traits.h", AbslTypeTraitsHeader); 1291 Headers.emplace_back("absl_optional.h", AbslOptionalHeader); 1292 Headers.emplace_back("base_optional.h", BaseOptionalHeader); 1293 Headers.emplace_back("unchecked_optional_access_test.h", R"( 1294 #include "absl_optional.h" 1295 #include "base_optional.h" 1296 #include "std_initializer_list.h" 1297 #include "std_optional.h" 1298 #include "std_string.h" 1299 #include "std_utility.h" 1300 1301 template <typename T> 1302 T Make(); 1303 )"); 1304 UncheckedOptionalAccessModelOptions Options{ 1305 /*IgnoreSmartPointerDereference=*/true}; 1306 std::vector<SourceLocation> Diagnostics; 1307 llvm::Error Error = checkDataflow<UncheckedOptionalAccessModel>( 1308 AnalysisInputs<UncheckedOptionalAccessModel>( 1309 SourceCode, std::move(FuncMatcher), 1310 [](ASTContext &Ctx, Environment &) { 1311 return UncheckedOptionalAccessModel(Ctx); 1312 }) 1313 .withPostVisitCFG( 1314 [&Diagnostics, 1315 Diagnoser = UncheckedOptionalAccessDiagnoser(Options)]( 1316 ASTContext &Ctx, const CFGElement &Elt, 1317 const TransferStateForDiagnostics<NoopLattice> 1318 &State) mutable { 1319 auto EltDiagnostics = 1320 Diagnoser.diagnose(Ctx, &Elt, State.Env); 1321 llvm::move(EltDiagnostics, std::back_inserter(Diagnostics)); 1322 }) 1323 .withASTBuildArgs( 1324 {"-fsyntax-only", "-std=c++17", "-Wno-undefined-inline"}) 1325 .withASTBuildVirtualMappedFiles( 1326 tooling::FileContentMappings(Headers.begin(), Headers.end())), 1327 /*VerifyResults=*/[&Diagnostics]( 1328 const llvm::DenseMap<unsigned, std::string> 1329 &Annotations, 1330 const AnalysisOutputs &AO) { 1331 llvm::DenseSet<unsigned> AnnotationLines; 1332 for (const auto &[Line, _] : Annotations) { 1333 AnnotationLines.insert(Line); 1334 } 1335 auto &SrcMgr = AO.ASTCtx.getSourceManager(); 1336 llvm::DenseSet<unsigned> DiagnosticLines; 1337 for (SourceLocation &Loc : Diagnostics) { 1338 DiagnosticLines.insert(SrcMgr.getPresumedLineNumber(Loc)); 1339 } 1340 1341 EXPECT_THAT(DiagnosticLines, ContainerEq(AnnotationLines)); 1342 }); 1343 if (Error) 1344 FAIL() << llvm::toString(std::move(Error)); 1345 } 1346 }; 1347 1348 INSTANTIATE_TEST_SUITE_P( 1349 UncheckedOptionalUseTestInst, UncheckedOptionalAccessTest, 1350 ::testing::Values(OptionalTypeIdentifier{"std", "optional"}, 1351 OptionalTypeIdentifier{"absl", "optional"}, 1352 OptionalTypeIdentifier{"base", "Optional"}), 1353 [](const ::testing::TestParamInfo<OptionalTypeIdentifier> &Info) { 1354 return Info.param.NamespaceName; 1355 }); 1356 1357 TEST_P(UncheckedOptionalAccessTest, EmptyFunctionBody) { 1358 ExpectDiagnosticsFor(R"( 1359 void target() { 1360 (void)0; 1361 } 1362 )"); 1363 } 1364 1365 TEST_P(UncheckedOptionalAccessTest, UnwrapUsingValueNoCheck) { 1366 ExpectDiagnosticsFor( 1367 R"( 1368 #include "unchecked_optional_access_test.h" 1369 1370 void target($ns::$optional<int> opt) { 1371 opt.value(); // [[unsafe]] 1372 } 1373 )"); 1374 1375 ExpectDiagnosticsFor( 1376 R"( 1377 #include "unchecked_optional_access_test.h" 1378 1379 void target($ns::$optional<int> opt) { 1380 std::move(opt).value(); // [[unsafe]] 1381 } 1382 )"); 1383 } 1384 1385 TEST_P(UncheckedOptionalAccessTest, UnwrapUsingOperatorStarNoCheck) { 1386 ExpectDiagnosticsFor( 1387 R"( 1388 #include "unchecked_optional_access_test.h" 1389 1390 void target($ns::$optional<int> opt) { 1391 *opt; // [[unsafe]] 1392 } 1393 )"); 1394 1395 ExpectDiagnosticsFor( 1396 R"( 1397 #include "unchecked_optional_access_test.h" 1398 1399 void target($ns::$optional<int> opt) { 1400 *std::move(opt); // [[unsafe]] 1401 } 1402 )"); 1403 } 1404 1405 TEST_P(UncheckedOptionalAccessTest, UnwrapUsingOperatorArrowNoCheck) { 1406 ExpectDiagnosticsFor( 1407 R"( 1408 #include "unchecked_optional_access_test.h" 1409 1410 struct Foo { 1411 void foo(); 1412 }; 1413 1414 void target($ns::$optional<Foo> opt) { 1415 opt->foo(); // [[unsafe]] 1416 } 1417 )"); 1418 1419 ExpectDiagnosticsFor( 1420 R"( 1421 #include "unchecked_optional_access_test.h" 1422 1423 struct Foo { 1424 void foo(); 1425 }; 1426 1427 void target($ns::$optional<Foo> opt) { 1428 std::move(opt)->foo(); // [[unsafe]] 1429 } 1430 )"); 1431 } 1432 1433 TEST_P(UncheckedOptionalAccessTest, HasValueCheck) { 1434 ExpectDiagnosticsFor(R"( 1435 #include "unchecked_optional_access_test.h" 1436 1437 void target($ns::$optional<int> opt) { 1438 if (opt.has_value()) { 1439 opt.value(); 1440 } 1441 } 1442 )"); 1443 } 1444 1445 TEST_P(UncheckedOptionalAccessTest, OperatorBoolCheck) { 1446 ExpectDiagnosticsFor(R"( 1447 #include "unchecked_optional_access_test.h" 1448 1449 void target($ns::$optional<int> opt) { 1450 if (opt) { 1451 opt.value(); 1452 } 1453 } 1454 )"); 1455 } 1456 1457 TEST_P(UncheckedOptionalAccessTest, UnwrapFunctionCallResultNoCheck) { 1458 ExpectDiagnosticsFor( 1459 R"( 1460 #include "unchecked_optional_access_test.h" 1461 1462 void target() { 1463 Make<$ns::$optional<int>>().value(); // [[unsafe]] 1464 (void)0; 1465 } 1466 )"); 1467 1468 ExpectDiagnosticsFor( 1469 R"( 1470 #include "unchecked_optional_access_test.h" 1471 1472 void target($ns::$optional<int> opt) { 1473 std::move(opt).value(); // [[unsafe]] 1474 } 1475 )"); 1476 } 1477 1478 TEST_P(UncheckedOptionalAccessTest, DefaultConstructor) { 1479 ExpectDiagnosticsFor( 1480 R"( 1481 #include "unchecked_optional_access_test.h" 1482 1483 void target() { 1484 $ns::$optional<int> opt; 1485 opt.value(); // [[unsafe]] 1486 } 1487 )"); 1488 } 1489 1490 TEST_P(UncheckedOptionalAccessTest, NulloptConstructor) { 1491 ExpectDiagnosticsFor( 1492 R"( 1493 #include "unchecked_optional_access_test.h" 1494 1495 void target() { 1496 $ns::$optional<int> opt($ns::nullopt); 1497 opt.value(); // [[unsafe]] 1498 } 1499 )"); 1500 } 1501 1502 TEST_P(UncheckedOptionalAccessTest, NulloptConstructorWithSugaredType) { 1503 ExpectDiagnosticsFor( 1504 R"( 1505 #include "unchecked_optional_access_test.h" 1506 template <typename T> 1507 using wrapper = T; 1508 1509 template <typename T> 1510 wrapper<T> wrap(T); 1511 1512 void target() { 1513 $ns::$optional<int> opt(wrap($ns::nullopt)); 1514 opt.value(); // [[unsafe]] 1515 } 1516 )"); 1517 } 1518 1519 TEST_P(UncheckedOptionalAccessTest, InPlaceConstructor) { 1520 ExpectDiagnosticsFor(R"( 1521 #include "unchecked_optional_access_test.h" 1522 1523 void target() { 1524 $ns::$optional<int> opt($ns::in_place, 3); 1525 opt.value(); 1526 } 1527 )"); 1528 1529 ExpectDiagnosticsFor(R"( 1530 #include "unchecked_optional_access_test.h" 1531 1532 struct Foo {}; 1533 1534 void target() { 1535 $ns::$optional<Foo> opt($ns::in_place); 1536 opt.value(); 1537 } 1538 )"); 1539 1540 ExpectDiagnosticsFor(R"( 1541 #include "unchecked_optional_access_test.h" 1542 1543 struct Foo { 1544 explicit Foo(int, bool); 1545 }; 1546 1547 void target() { 1548 $ns::$optional<Foo> opt($ns::in_place, 3, false); 1549 opt.value(); 1550 } 1551 )"); 1552 1553 ExpectDiagnosticsFor(R"( 1554 #include "unchecked_optional_access_test.h" 1555 1556 struct Foo { 1557 explicit Foo(std::initializer_list<int>); 1558 }; 1559 1560 void target() { 1561 $ns::$optional<Foo> opt($ns::in_place, {3}); 1562 opt.value(); 1563 } 1564 )"); 1565 } 1566 1567 TEST_P(UncheckedOptionalAccessTest, ValueConstructor) { 1568 ExpectDiagnosticsFor(R"( 1569 #include "unchecked_optional_access_test.h" 1570 1571 void target() { 1572 $ns::$optional<int> opt(21); 1573 opt.value(); 1574 } 1575 )"); 1576 1577 ExpectDiagnosticsFor(R"( 1578 #include "unchecked_optional_access_test.h" 1579 1580 void target() { 1581 $ns::$optional<int> opt = $ns::$optional<int>(21); 1582 opt.value(); 1583 } 1584 )"); 1585 ExpectDiagnosticsFor(R"( 1586 #include "unchecked_optional_access_test.h" 1587 1588 void target() { 1589 $ns::$optional<$ns::$optional<int>> opt(Make<$ns::$optional<int>>()); 1590 opt.value(); 1591 } 1592 )"); 1593 1594 ExpectDiagnosticsFor(R"( 1595 #include "unchecked_optional_access_test.h" 1596 1597 struct MyString { 1598 MyString(const char*); 1599 }; 1600 1601 void target() { 1602 $ns::$optional<MyString> opt("foo"); 1603 opt.value(); 1604 } 1605 )"); 1606 1607 ExpectDiagnosticsFor(R"( 1608 #include "unchecked_optional_access_test.h" 1609 1610 struct Foo {}; 1611 1612 struct Bar { 1613 Bar(const Foo&); 1614 }; 1615 1616 void target() { 1617 $ns::$optional<Bar> opt(Make<Foo>()); 1618 opt.value(); 1619 } 1620 )"); 1621 1622 ExpectDiagnosticsFor(R"( 1623 #include "unchecked_optional_access_test.h" 1624 1625 struct Foo { 1626 explicit Foo(int); 1627 }; 1628 1629 void target() { 1630 $ns::$optional<Foo> opt(3); 1631 opt.value(); 1632 } 1633 )"); 1634 } 1635 1636 TEST_P(UncheckedOptionalAccessTest, ConvertibleOptionalConstructor) { 1637 ExpectDiagnosticsFor( 1638 R"( 1639 #include "unchecked_optional_access_test.h" 1640 1641 struct Foo {}; 1642 1643 struct Bar { 1644 Bar(const Foo&); 1645 }; 1646 1647 void target() { 1648 $ns::$optional<Bar> opt(Make<$ns::$optional<Foo>>()); 1649 opt.value(); // [[unsafe]] 1650 } 1651 )"); 1652 1653 ExpectDiagnosticsFor( 1654 R"( 1655 #include "unchecked_optional_access_test.h" 1656 1657 struct Foo {}; 1658 1659 struct Bar { 1660 explicit Bar(const Foo&); 1661 }; 1662 1663 void target() { 1664 $ns::$optional<Bar> opt(Make<$ns::$optional<Foo>>()); 1665 opt.value(); // [[unsafe]] 1666 } 1667 )"); 1668 1669 ExpectDiagnosticsFor( 1670 R"( 1671 #include "unchecked_optional_access_test.h" 1672 1673 struct Foo {}; 1674 1675 struct Bar { 1676 Bar(const Foo&); 1677 }; 1678 1679 void target() { 1680 $ns::$optional<Foo> opt1 = $ns::nullopt; 1681 $ns::$optional<Bar> opt2(opt1); 1682 opt2.value(); // [[unsafe]] 1683 } 1684 )"); 1685 1686 ExpectDiagnosticsFor(R"( 1687 #include "unchecked_optional_access_test.h" 1688 1689 struct Foo {}; 1690 1691 struct Bar { 1692 Bar(const Foo&); 1693 }; 1694 1695 void target() { 1696 $ns::$optional<Foo> opt1(Make<Foo>()); 1697 $ns::$optional<Bar> opt2(opt1); 1698 opt2.value(); 1699 } 1700 )"); 1701 1702 ExpectDiagnosticsFor(R"( 1703 #include "unchecked_optional_access_test.h" 1704 1705 struct Foo {}; 1706 1707 struct Bar { 1708 explicit Bar(const Foo&); 1709 }; 1710 1711 void target() { 1712 $ns::$optional<Foo> opt1(Make<Foo>()); 1713 $ns::$optional<Bar> opt2(opt1); 1714 opt2.value(); 1715 } 1716 )"); 1717 } 1718 1719 TEST_P(UncheckedOptionalAccessTest, MakeOptional) { 1720 ExpectDiagnosticsFor(R"( 1721 #include "unchecked_optional_access_test.h" 1722 1723 void target() { 1724 $ns::$optional<int> opt = $ns::make_optional(0); 1725 opt.value(); 1726 } 1727 )"); 1728 1729 ExpectDiagnosticsFor(R"( 1730 #include "unchecked_optional_access_test.h" 1731 1732 struct Foo { 1733 Foo(int, int); 1734 }; 1735 1736 void target() { 1737 $ns::$optional<Foo> opt = $ns::make_optional<Foo>(21, 22); 1738 opt.value(); 1739 } 1740 )"); 1741 1742 ExpectDiagnosticsFor(R"( 1743 #include "unchecked_optional_access_test.h" 1744 1745 struct Foo { 1746 constexpr Foo(std::initializer_list<char>); 1747 }; 1748 1749 void target() { 1750 char a = 'a'; 1751 $ns::$optional<Foo> opt = $ns::make_optional<Foo>({a}); 1752 opt.value(); 1753 } 1754 )"); 1755 } 1756 1757 TEST_P(UncheckedOptionalAccessTest, ValueOr) { 1758 ExpectDiagnosticsFor(R"( 1759 #include "unchecked_optional_access_test.h" 1760 1761 void target() { 1762 $ns::$optional<int> opt; 1763 opt.value_or(0); 1764 (void)0; 1765 } 1766 )"); 1767 } 1768 1769 TEST_P(UncheckedOptionalAccessTest, ValueOrComparison) { 1770 // Pointers. 1771 ExpectDiagnosticsFor( 1772 R"code( 1773 #include "unchecked_optional_access_test.h" 1774 1775 void target($ns::$optional<int*> opt) { 1776 if (opt.value_or(nullptr) != nullptr) { 1777 opt.value(); 1778 } else { 1779 opt.value(); // [[unsafe]] 1780 } 1781 } 1782 )code"); 1783 1784 // Integers. 1785 ExpectDiagnosticsFor( 1786 R"code( 1787 #include "unchecked_optional_access_test.h" 1788 1789 void target($ns::$optional<int> opt) { 1790 if (opt.value_or(0) != 0) { 1791 opt.value(); 1792 } else { 1793 opt.value(); // [[unsafe]] 1794 } 1795 } 1796 )code"); 1797 1798 // Strings. 1799 ExpectDiagnosticsFor( 1800 R"code( 1801 #include "unchecked_optional_access_test.h" 1802 1803 void target($ns::$optional<std::string> opt) { 1804 if (!opt.value_or("").empty()) { 1805 opt.value(); 1806 } else { 1807 opt.value(); // [[unsafe]] 1808 } 1809 } 1810 )code"); 1811 1812 ExpectDiagnosticsFor( 1813 R"code( 1814 #include "unchecked_optional_access_test.h" 1815 1816 void target($ns::$optional<std::string> opt) { 1817 if (opt.value_or("") != "") { 1818 opt.value(); 1819 } else { 1820 opt.value(); // [[unsafe]] 1821 } 1822 } 1823 )code"); 1824 1825 // Pointer-to-optional. 1826 // 1827 // FIXME: make `opt` a parameter directly, once we ensure that all `optional` 1828 // values have a `has_value` property. 1829 ExpectDiagnosticsFor( 1830 R"code( 1831 #include "unchecked_optional_access_test.h" 1832 1833 void target($ns::$optional<int> p) { 1834 $ns::$optional<int> *opt = &p; 1835 if (opt->value_or(0) != 0) { 1836 opt->value(); 1837 } else { 1838 opt->value(); // [[unsafe]] 1839 } 1840 } 1841 )code"); 1842 } 1843 1844 TEST_P(UncheckedOptionalAccessTest, Emplace) { 1845 ExpectDiagnosticsFor(R"( 1846 #include "unchecked_optional_access_test.h" 1847 1848 void target() { 1849 $ns::$optional<int> opt; 1850 opt.emplace(0); 1851 opt.value(); 1852 } 1853 )"); 1854 1855 ExpectDiagnosticsFor(R"( 1856 #include "unchecked_optional_access_test.h" 1857 1858 void target($ns::$optional<int> *opt) { 1859 opt->emplace(0); 1860 opt->value(); 1861 } 1862 )"); 1863 1864 // FIXME: Add tests that call `emplace` in conditional branches: 1865 // ExpectDiagnosticsFor( 1866 // R"( 1867 // #include "unchecked_optional_access_test.h" 1868 // 1869 // void target($ns::$optional<int> opt, bool b) { 1870 // if (b) { 1871 // opt.emplace(0); 1872 // } 1873 // if (b) { 1874 // opt.value(); 1875 // } else { 1876 // opt.value(); // [[unsafe]] 1877 // } 1878 // } 1879 // )"); 1880 } 1881 1882 TEST_P(UncheckedOptionalAccessTest, Reset) { 1883 ExpectDiagnosticsFor( 1884 R"( 1885 #include "unchecked_optional_access_test.h" 1886 1887 void target() { 1888 $ns::$optional<int> opt = $ns::make_optional(0); 1889 opt.reset(); 1890 opt.value(); // [[unsafe]] 1891 } 1892 )"); 1893 1894 ExpectDiagnosticsFor( 1895 R"( 1896 #include "unchecked_optional_access_test.h" 1897 1898 void target($ns::$optional<int> &opt) { 1899 if (opt.has_value()) { 1900 opt.reset(); 1901 opt.value(); // [[unsafe]] 1902 } 1903 } 1904 )"); 1905 1906 // FIXME: Add tests that call `reset` in conditional branches: 1907 // ExpectDiagnosticsFor( 1908 // R"( 1909 // #include "unchecked_optional_access_test.h" 1910 // 1911 // void target(bool b) { 1912 // $ns::$optional<int> opt = $ns::make_optional(0); 1913 // if (b) { 1914 // opt.reset(); 1915 // } 1916 // if (b) { 1917 // opt.value(); // [[unsafe]] 1918 // } else { 1919 // opt.value(); 1920 // } 1921 // } 1922 // )"); 1923 } 1924 1925 TEST_P(UncheckedOptionalAccessTest, ValueAssignment) { 1926 ExpectDiagnosticsFor(R"( 1927 #include "unchecked_optional_access_test.h" 1928 1929 struct Foo {}; 1930 1931 void target() { 1932 $ns::$optional<Foo> opt; 1933 opt = Foo(); 1934 opt.value(); 1935 } 1936 )"); 1937 1938 ExpectDiagnosticsFor(R"( 1939 #include "unchecked_optional_access_test.h" 1940 1941 struct Foo {}; 1942 1943 void target() { 1944 $ns::$optional<Foo> opt; 1945 (opt = Foo()).value(); 1946 (void)0; 1947 } 1948 )"); 1949 1950 ExpectDiagnosticsFor(R"( 1951 #include "unchecked_optional_access_test.h" 1952 1953 struct MyString { 1954 MyString(const char*); 1955 }; 1956 1957 void target() { 1958 $ns::$optional<MyString> opt; 1959 opt = "foo"; 1960 opt.value(); 1961 } 1962 )"); 1963 1964 ExpectDiagnosticsFor(R"( 1965 #include "unchecked_optional_access_test.h" 1966 1967 struct MyString { 1968 MyString(const char*); 1969 }; 1970 1971 void target() { 1972 $ns::$optional<MyString> opt; 1973 (opt = "foo").value(); 1974 } 1975 )"); 1976 } 1977 1978 TEST_P(UncheckedOptionalAccessTest, OptionalConversionAssignment) { 1979 ExpectDiagnosticsFor( 1980 R"( 1981 #include "unchecked_optional_access_test.h" 1982 1983 struct Foo {}; 1984 1985 struct Bar { 1986 Bar(const Foo&); 1987 }; 1988 1989 void target() { 1990 $ns::$optional<Foo> opt1 = Foo(); 1991 $ns::$optional<Bar> opt2; 1992 opt2 = opt1; 1993 opt2.value(); 1994 } 1995 )"); 1996 1997 ExpectDiagnosticsFor( 1998 R"( 1999 #include "unchecked_optional_access_test.h" 2000 2001 struct Foo {}; 2002 2003 struct Bar { 2004 Bar(const Foo&); 2005 }; 2006 2007 void target() { 2008 $ns::$optional<Foo> opt1; 2009 $ns::$optional<Bar> opt2; 2010 if (opt2.has_value()) { 2011 opt2 = opt1; 2012 opt2.value(); // [[unsafe]] 2013 } 2014 } 2015 )"); 2016 2017 ExpectDiagnosticsFor( 2018 R"( 2019 #include "unchecked_optional_access_test.h" 2020 2021 struct Foo {}; 2022 2023 struct Bar { 2024 Bar(const Foo&); 2025 }; 2026 2027 void target() { 2028 $ns::$optional<Foo> opt1 = Foo(); 2029 $ns::$optional<Bar> opt2; 2030 (opt2 = opt1).value(); 2031 (void)0; 2032 } 2033 )"); 2034 } 2035 2036 TEST_P(UncheckedOptionalAccessTest, NulloptAssignment) { 2037 ExpectDiagnosticsFor( 2038 R"( 2039 #include "unchecked_optional_access_test.h" 2040 2041 void target() { 2042 $ns::$optional<int> opt = 3; 2043 opt = $ns::nullopt; 2044 opt.value(); // [[unsafe]] 2045 } 2046 )"); 2047 2048 ExpectDiagnosticsFor( 2049 R"( 2050 #include "unchecked_optional_access_test.h" 2051 2052 void target() { 2053 $ns::$optional<int> opt = 3; 2054 (opt = $ns::nullopt).value(); // [[unsafe]] 2055 } 2056 )"); 2057 } 2058 2059 TEST_P(UncheckedOptionalAccessTest, OptionalSwap) { 2060 ExpectDiagnosticsFor( 2061 R"( 2062 #include "unchecked_optional_access_test.h" 2063 2064 void target() { 2065 $ns::$optional<int> opt1 = $ns::nullopt; 2066 $ns::$optional<int> opt2 = 3; 2067 2068 opt1.swap(opt2); 2069 2070 opt1.value(); 2071 2072 opt2.value(); // [[unsafe]] 2073 } 2074 )"); 2075 2076 ExpectDiagnosticsFor( 2077 R"( 2078 #include "unchecked_optional_access_test.h" 2079 2080 void target() { 2081 $ns::$optional<int> opt1 = $ns::nullopt; 2082 $ns::$optional<int> opt2 = 3; 2083 2084 opt2.swap(opt1); 2085 2086 opt1.value(); 2087 2088 opt2.value(); // [[unsafe]] 2089 } 2090 )"); 2091 } 2092 2093 TEST_P(UncheckedOptionalAccessTest, StdSwap) { 2094 ExpectDiagnosticsFor( 2095 R"( 2096 #include "unchecked_optional_access_test.h" 2097 2098 void target() { 2099 $ns::$optional<int> opt1 = $ns::nullopt; 2100 $ns::$optional<int> opt2 = 3; 2101 2102 std::swap(opt1, opt2); 2103 2104 opt1.value(); 2105 2106 opt2.value(); // [[unsafe]] 2107 } 2108 )"); 2109 2110 ExpectDiagnosticsFor( 2111 R"( 2112 #include "unchecked_optional_access_test.h" 2113 2114 void target() { 2115 $ns::$optional<int> opt1 = $ns::nullopt; 2116 $ns::$optional<int> opt2 = 3; 2117 2118 std::swap(opt2, opt1); 2119 2120 opt1.value(); 2121 2122 opt2.value(); // [[unsafe]] 2123 } 2124 )"); 2125 } 2126 2127 TEST_P(UncheckedOptionalAccessTest, UniquePtrToOptional) { 2128 // We suppress diagnostics for optionals in smart pointers (other than 2129 // `optional` itself). 2130 ExpectDiagnosticsFor( 2131 R"( 2132 #include "unchecked_optional_access_test.h" 2133 2134 template <typename T> 2135 struct smart_ptr { 2136 T& operator*() &; 2137 T* operator->(); 2138 }; 2139 2140 void target() { 2141 smart_ptr<$ns::$optional<bool>> foo; 2142 foo->value(); 2143 (*foo).value(); 2144 } 2145 )"); 2146 } 2147 2148 TEST_P(UncheckedOptionalAccessTest, UniquePtrToStructWithOptionalField) { 2149 // We suppress diagnostics for optional fields reachable from smart pointers 2150 // (other than `optional` itself) through (exactly) one member access. 2151 ExpectDiagnosticsFor( 2152 R"( 2153 #include "unchecked_optional_access_test.h" 2154 2155 template <typename T> 2156 struct smart_ptr { 2157 T& operator*() &; 2158 T* operator->(); 2159 }; 2160 2161 struct Foo { 2162 $ns::$optional<int> opt; 2163 }; 2164 2165 void target() { 2166 smart_ptr<Foo> foo; 2167 *foo->opt; 2168 *(*foo).opt; 2169 } 2170 )"); 2171 } 2172 2173 TEST_P(UncheckedOptionalAccessTest, CallReturningOptional) { 2174 ExpectDiagnosticsFor( 2175 R"( 2176 #include "unchecked_optional_access_test.h" 2177 2178 $ns::$optional<int> MakeOpt(); 2179 2180 void target() { 2181 $ns::$optional<int> opt = 0; 2182 opt = MakeOpt(); 2183 opt.value(); // [[unsafe]] 2184 } 2185 )"); 2186 ExpectDiagnosticsFor( 2187 R"( 2188 #include "unchecked_optional_access_test.h" 2189 2190 const $ns::$optional<int>& MakeOpt(); 2191 2192 void target() { 2193 $ns::$optional<int> opt = 0; 2194 opt = MakeOpt(); 2195 opt.value(); // [[unsafe]] 2196 } 2197 )"); 2198 2199 ExpectDiagnosticsFor( 2200 R"( 2201 #include "unchecked_optional_access_test.h" 2202 2203 using IntOpt = $ns::$optional<int>; 2204 IntOpt MakeOpt(); 2205 2206 void target() { 2207 IntOpt opt = 0; 2208 opt = MakeOpt(); 2209 opt.value(); // [[unsafe]] 2210 } 2211 )"); 2212 2213 ExpectDiagnosticsFor( 2214 R"( 2215 #include "unchecked_optional_access_test.h" 2216 2217 using IntOpt = $ns::$optional<int>; 2218 const IntOpt& MakeOpt(); 2219 2220 void target() { 2221 IntOpt opt = 0; 2222 opt = MakeOpt(); 2223 opt.value(); // [[unsafe]] 2224 } 2225 )"); 2226 } 2227 2228 2229 TEST_P(UncheckedOptionalAccessTest, EqualityCheckLeftSet) { 2230 ExpectDiagnosticsFor( 2231 R"( 2232 #include "unchecked_optional_access_test.h" 2233 2234 void target() { 2235 $ns::$optional<int> opt1 = 3; 2236 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2237 2238 if (opt1 == opt2) { 2239 opt2.value(); 2240 } else { 2241 opt2.value(); // [[unsafe]] 2242 } 2243 } 2244 )"); 2245 } 2246 2247 TEST_P(UncheckedOptionalAccessTest, EqualityCheckRightSet) { 2248 ExpectDiagnosticsFor( 2249 R"( 2250 #include "unchecked_optional_access_test.h" 2251 2252 void target() { 2253 $ns::$optional<int> opt1 = 3; 2254 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2255 2256 if (opt2 == opt1) { 2257 opt2.value(); 2258 } else { 2259 opt2.value(); // [[unsafe]] 2260 } 2261 } 2262 )"); 2263 } 2264 2265 TEST_P(UncheckedOptionalAccessTest, EqualityCheckVerifySetAfterEq) { 2266 ExpectDiagnosticsFor( 2267 R"( 2268 #include "unchecked_optional_access_test.h" 2269 2270 void target() { 2271 $ns::$optional<int> opt1 = Make<$ns::$optional<int>>(); 2272 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2273 2274 if (opt1 == opt2) { 2275 if (opt1.has_value()) 2276 opt2.value(); 2277 if (opt2.has_value()) 2278 opt1.value(); 2279 } 2280 } 2281 )"); 2282 } 2283 2284 TEST_P(UncheckedOptionalAccessTest, EqualityCheckLeftUnset) { 2285 ExpectDiagnosticsFor( 2286 R"( 2287 #include "unchecked_optional_access_test.h" 2288 2289 void target() { 2290 $ns::$optional<int> opt1 = $ns::nullopt; 2291 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2292 2293 if (opt1 == opt2) { 2294 opt2.value(); // [[unsafe]] 2295 } else { 2296 opt2.value(); 2297 } 2298 } 2299 )"); 2300 } 2301 2302 TEST_P(UncheckedOptionalAccessTest, EqualityCheckRightUnset) { 2303 ExpectDiagnosticsFor( 2304 R"( 2305 #include "unchecked_optional_access_test.h" 2306 2307 void target() { 2308 $ns::$optional<int> opt1 = $ns::nullopt; 2309 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2310 2311 if (opt2 == opt1) { 2312 opt2.value(); // [[unsafe]] 2313 } else { 2314 opt2.value(); 2315 } 2316 } 2317 )"); 2318 } 2319 2320 TEST_P(UncheckedOptionalAccessTest, EqualityCheckRightNullopt) { 2321 ExpectDiagnosticsFor( 2322 R"( 2323 #include "unchecked_optional_access_test.h" 2324 2325 void target() { 2326 $ns::$optional<int> opt = Make<$ns::$optional<int>>(); 2327 2328 if (opt == $ns::nullopt) { 2329 opt.value(); // [[unsafe]] 2330 } else { 2331 opt.value(); 2332 } 2333 } 2334 )"); 2335 } 2336 2337 TEST_P(UncheckedOptionalAccessTest, EqualityCheckLeftNullopt) { 2338 ExpectDiagnosticsFor( 2339 R"( 2340 #include "unchecked_optional_access_test.h" 2341 2342 void target() { 2343 $ns::$optional<int> opt = Make<$ns::$optional<int>>(); 2344 2345 if ($ns::nullopt == opt) { 2346 opt.value(); // [[unsafe]] 2347 } else { 2348 opt.value(); 2349 } 2350 } 2351 )"); 2352 } 2353 2354 TEST_P(UncheckedOptionalAccessTest, EqualityCheckRightValue) { 2355 ExpectDiagnosticsFor( 2356 R"( 2357 #include "unchecked_optional_access_test.h" 2358 2359 void target() { 2360 $ns::$optional<int> opt = Make<$ns::$optional<int>>(); 2361 2362 if (opt == 3) { 2363 opt.value(); 2364 } else { 2365 opt.value(); // [[unsafe]] 2366 } 2367 } 2368 )"); 2369 } 2370 2371 TEST_P(UncheckedOptionalAccessTest, EqualityCheckLeftValue) { 2372 ExpectDiagnosticsFor( 2373 R"( 2374 #include "unchecked_optional_access_test.h" 2375 2376 void target() { 2377 $ns::$optional<int> opt = Make<$ns::$optional<int>>(); 2378 2379 if (3 == opt) { 2380 opt.value(); 2381 } else { 2382 opt.value(); // [[unsafe]] 2383 } 2384 } 2385 )"); 2386 } 2387 2388 TEST_P(UncheckedOptionalAccessTest, InequalityCheckLeftSet) { 2389 ExpectDiagnosticsFor( 2390 R"( 2391 #include "unchecked_optional_access_test.h" 2392 2393 void target() { 2394 $ns::$optional<int> opt1 = 3; 2395 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2396 2397 if (opt1 != opt2) { 2398 opt2.value(); // [[unsafe]] 2399 } else { 2400 opt2.value(); 2401 } 2402 } 2403 )"); 2404 } 2405 2406 TEST_P(UncheckedOptionalAccessTest, InequalityCheckRightSet) { 2407 ExpectDiagnosticsFor( 2408 R"( 2409 #include "unchecked_optional_access_test.h" 2410 2411 void target() { 2412 $ns::$optional<int> opt1 = 3; 2413 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2414 2415 if (opt2 != opt1) { 2416 opt2.value(); // [[unsafe]] 2417 } else { 2418 opt2.value(); 2419 } 2420 } 2421 )"); 2422 } 2423 2424 TEST_P(UncheckedOptionalAccessTest, InequalityCheckVerifySetAfterEq) { 2425 ExpectDiagnosticsFor( 2426 R"( 2427 #include "unchecked_optional_access_test.h" 2428 2429 void target() { 2430 $ns::$optional<int> opt1 = Make<$ns::$optional<int>>(); 2431 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2432 2433 if (opt1 != opt2) { 2434 if (opt1.has_value()) 2435 opt2.value(); // [[unsafe]] 2436 if (opt2.has_value()) 2437 opt1.value(); // [[unsafe]] 2438 } 2439 } 2440 )"); 2441 } 2442 2443 TEST_P(UncheckedOptionalAccessTest, InequalityCheckLeftUnset) { 2444 ExpectDiagnosticsFor( 2445 R"( 2446 #include "unchecked_optional_access_test.h" 2447 2448 void target() { 2449 $ns::$optional<int> opt1 = $ns::nullopt; 2450 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2451 2452 if (opt1 != opt2) { 2453 opt2.value(); 2454 } else { 2455 opt2.value(); // [[unsafe]] 2456 } 2457 } 2458 )"); 2459 } 2460 2461 TEST_P(UncheckedOptionalAccessTest, InequalityCheckRightUnset) { 2462 ExpectDiagnosticsFor( 2463 R"( 2464 #include "unchecked_optional_access_test.h" 2465 2466 void target() { 2467 $ns::$optional<int> opt1 = $ns::nullopt; 2468 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2469 2470 if (opt2 != opt1) { 2471 opt2.value(); 2472 } else { 2473 opt2.value(); // [[unsafe]] 2474 } 2475 } 2476 )"); 2477 } 2478 2479 TEST_P(UncheckedOptionalAccessTest, InequalityCheckRightNullopt) { 2480 ExpectDiagnosticsFor( 2481 R"( 2482 #include "unchecked_optional_access_test.h" 2483 2484 void target() { 2485 $ns::$optional<int> opt = Make<$ns::$optional<int>>(); 2486 2487 if (opt != $ns::nullopt) { 2488 opt.value(); 2489 } else { 2490 opt.value(); // [[unsafe]] 2491 } 2492 } 2493 )"); 2494 } 2495 2496 TEST_P(UncheckedOptionalAccessTest, InequalityCheckLeftNullopt) { 2497 ExpectDiagnosticsFor( 2498 R"( 2499 #include "unchecked_optional_access_test.h" 2500 2501 void target() { 2502 $ns::$optional<int> opt = Make<$ns::$optional<int>>(); 2503 2504 if ($ns::nullopt != opt) { 2505 opt.value(); 2506 } else { 2507 opt.value(); // [[unsafe]] 2508 } 2509 } 2510 )"); 2511 } 2512 2513 TEST_P(UncheckedOptionalAccessTest, InequalityCheckRightValue) { 2514 ExpectDiagnosticsFor( 2515 R"( 2516 #include "unchecked_optional_access_test.h" 2517 2518 void target() { 2519 $ns::$optional<int> opt = Make<$ns::$optional<int>>(); 2520 2521 if (opt != 3) { 2522 opt.value(); // [[unsafe]] 2523 } else { 2524 opt.value(); 2525 } 2526 } 2527 )"); 2528 } 2529 2530 TEST_P(UncheckedOptionalAccessTest, InequalityCheckLeftValue) { 2531 ExpectDiagnosticsFor( 2532 R"( 2533 #include "unchecked_optional_access_test.h" 2534 2535 void target() { 2536 $ns::$optional<int> opt = Make<$ns::$optional<int>>(); 2537 2538 if (3 != opt) { 2539 opt.value(); // [[unsafe]] 2540 } else { 2541 opt.value(); 2542 } 2543 } 2544 )"); 2545 } 2546 2547 // Verifies that the model sees through aliases. 2548 TEST_P(UncheckedOptionalAccessTest, WithAlias) { 2549 ExpectDiagnosticsFor( 2550 R"( 2551 #include "unchecked_optional_access_test.h" 2552 2553 template <typename T> 2554 using MyOptional = $ns::$optional<T>; 2555 2556 void target(MyOptional<int> opt) { 2557 opt.value(); // [[unsafe]] 2558 } 2559 )"); 2560 } 2561 2562 TEST_P(UncheckedOptionalAccessTest, OptionalValueOptional) { 2563 // Basic test that nested values are populated. We nest an optional because 2564 // its easy to use in a test, but the type of the nested value shouldn't 2565 // matter. 2566 ExpectDiagnosticsFor( 2567 R"( 2568 #include "unchecked_optional_access_test.h" 2569 2570 using Foo = $ns::$optional<std::string>; 2571 2572 void target($ns::$optional<Foo> foo) { 2573 if (foo && *foo) { 2574 foo->value(); 2575 } 2576 } 2577 )"); 2578 2579 // Mutation is supported for nested values. 2580 ExpectDiagnosticsFor( 2581 R"( 2582 #include "unchecked_optional_access_test.h" 2583 2584 using Foo = $ns::$optional<std::string>; 2585 2586 void target($ns::$optional<Foo> foo) { 2587 if (foo && *foo) { 2588 foo->reset(); 2589 foo->value(); // [[unsafe]] 2590 } 2591 } 2592 )"); 2593 } 2594 2595 // Tests that structs can be nested. We use an optional field because its easy 2596 // to use in a test, but the type of the field shouldn't matter. 2597 TEST_P(UncheckedOptionalAccessTest, OptionalValueStruct) { 2598 ExpectDiagnosticsFor( 2599 R"( 2600 #include "unchecked_optional_access_test.h" 2601 2602 struct Foo { 2603 $ns::$optional<std::string> opt; 2604 }; 2605 2606 void target($ns::$optional<Foo> foo) { 2607 if (foo && foo->opt) { 2608 foo->opt.value(); 2609 } 2610 } 2611 )"); 2612 } 2613 2614 TEST_P(UncheckedOptionalAccessTest, OptionalValueInitialization) { 2615 // FIXME: Fix when to initialize `value`. All unwrapping should be safe in 2616 // this example, but `value` initialization is done multiple times during the 2617 // fixpoint iterations and joining the environment won't correctly merge them. 2618 ExpectDiagnosticsFor( 2619 R"( 2620 #include "unchecked_optional_access_test.h" 2621 2622 using Foo = $ns::$optional<std::string>; 2623 2624 void target($ns::$optional<Foo> foo, bool b) { 2625 if (!foo.has_value()) return; 2626 if (b) { 2627 if (!foo->has_value()) return; 2628 // We have created `foo.value()`. 2629 foo->value(); 2630 } else { 2631 if (!foo->has_value()) return; 2632 // We have created `foo.value()` again, in a different environment. 2633 foo->value(); 2634 } 2635 // Now we merge the two values. UncheckedOptionalAccessModel::merge() will 2636 // throw away the "value" property. 2637 foo->value(); // [[unsafe]] 2638 } 2639 )"); 2640 } 2641 2642 // This test is aimed at the core model, not the diagnostic. It is a regression 2643 // test against a crash when using non-trivial smart pointers, like 2644 // `std::unique_ptr`. As such, it doesn't test the access itself, which would be 2645 // ignored regardless because of `IgnoreSmartPointerDereference = true`, above. 2646 TEST_P(UncheckedOptionalAccessTest, AssignThroughLvalueReferencePtr) { 2647 ExpectDiagnosticsFor( 2648 R"( 2649 #include "unchecked_optional_access_test.h" 2650 2651 template <typename T> 2652 struct smart_ptr { 2653 typename std::add_lvalue_reference<T>::type operator*() &; 2654 }; 2655 2656 void target() { 2657 smart_ptr<$ns::$optional<int>> x; 2658 // Verify that this assignment does not crash. 2659 *x = 3; 2660 } 2661 )"); 2662 } 2663 2664 TEST_P(UncheckedOptionalAccessTest, CorrelatedBranches) { 2665 ExpectDiagnosticsFor(R"code( 2666 #include "unchecked_optional_access_test.h" 2667 2668 void target(bool b, $ns::$optional<int> opt) { 2669 if (b || opt.has_value()) { 2670 if (!b) { 2671 opt.value(); 2672 } 2673 } 2674 } 2675 )code"); 2676 2677 ExpectDiagnosticsFor(R"code( 2678 #include "unchecked_optional_access_test.h" 2679 2680 void target(bool b, $ns::$optional<int> opt) { 2681 if (b && !opt.has_value()) return; 2682 if (b) { 2683 opt.value(); 2684 } 2685 } 2686 )code"); 2687 2688 ExpectDiagnosticsFor( 2689 R"code( 2690 #include "unchecked_optional_access_test.h" 2691 2692 void target(bool b, $ns::$optional<int> opt) { 2693 if (opt.has_value()) b = true; 2694 if (b) { 2695 opt.value(); // [[unsafe]] 2696 } 2697 } 2698 )code"); 2699 2700 ExpectDiagnosticsFor(R"code( 2701 #include "unchecked_optional_access_test.h" 2702 2703 void target(bool b, $ns::$optional<int> opt) { 2704 if (b) return; 2705 if (opt.has_value()) b = true; 2706 if (b) { 2707 opt.value(); 2708 } 2709 } 2710 )code"); 2711 2712 ExpectDiagnosticsFor(R"( 2713 #include "unchecked_optional_access_test.h" 2714 2715 void target(bool b, $ns::$optional<int> opt) { 2716 if (opt.has_value() == b) { 2717 if (b) { 2718 opt.value(); 2719 } 2720 } 2721 } 2722 )"); 2723 2724 ExpectDiagnosticsFor(R"( 2725 #include "unchecked_optional_access_test.h" 2726 2727 void target(bool b, $ns::$optional<int> opt) { 2728 if (opt.has_value() != b) { 2729 if (!b) { 2730 opt.value(); 2731 } 2732 } 2733 } 2734 )"); 2735 2736 ExpectDiagnosticsFor(R"( 2737 #include "unchecked_optional_access_test.h" 2738 2739 void target(bool b) { 2740 $ns::$optional<int> opt1 = $ns::nullopt; 2741 $ns::$optional<int> opt2; 2742 if (b) { 2743 opt2 = $ns::nullopt; 2744 } else { 2745 opt2 = $ns::nullopt; 2746 } 2747 if (opt2.has_value()) { 2748 opt1.value(); 2749 } 2750 } 2751 )"); 2752 } 2753 2754 TEST_P(UncheckedOptionalAccessTest, JoinDistinctValues) { 2755 ExpectDiagnosticsFor( 2756 R"code( 2757 #include "unchecked_optional_access_test.h" 2758 2759 void target(bool b) { 2760 $ns::$optional<int> opt; 2761 if (b) { 2762 opt = Make<$ns::$optional<int>>(); 2763 } else { 2764 opt = Make<$ns::$optional<int>>(); 2765 } 2766 if (opt.has_value()) { 2767 opt.value(); 2768 } else { 2769 opt.value(); // [[unsafe]] 2770 } 2771 } 2772 )code"); 2773 2774 ExpectDiagnosticsFor(R"code( 2775 #include "unchecked_optional_access_test.h" 2776 2777 void target(bool b) { 2778 $ns::$optional<int> opt; 2779 if (b) { 2780 opt = Make<$ns::$optional<int>>(); 2781 if (!opt.has_value()) return; 2782 } else { 2783 opt = Make<$ns::$optional<int>>(); 2784 if (!opt.has_value()) return; 2785 } 2786 opt.value(); 2787 } 2788 )code"); 2789 2790 ExpectDiagnosticsFor( 2791 R"code( 2792 #include "unchecked_optional_access_test.h" 2793 2794 void target(bool b) { 2795 $ns::$optional<int> opt; 2796 if (b) { 2797 opt = Make<$ns::$optional<int>>(); 2798 if (!opt.has_value()) return; 2799 } else { 2800 opt = Make<$ns::$optional<int>>(); 2801 } 2802 opt.value(); // [[unsafe]] 2803 } 2804 )code"); 2805 2806 ExpectDiagnosticsFor( 2807 R"code( 2808 #include "unchecked_optional_access_test.h" 2809 2810 void target(bool b) { 2811 $ns::$optional<int> opt; 2812 if (b) { 2813 opt = 1; 2814 } else { 2815 opt = 2; 2816 } 2817 opt.value(); 2818 } 2819 )code"); 2820 2821 ExpectDiagnosticsFor( 2822 R"code( 2823 #include "unchecked_optional_access_test.h" 2824 2825 void target(bool b) { 2826 $ns::$optional<int> opt; 2827 if (b) { 2828 opt = 1; 2829 } else { 2830 opt = Make<$ns::$optional<int>>(); 2831 } 2832 opt.value(); // [[unsafe]] 2833 } 2834 )code"); 2835 } 2836 2837 TEST_P(UncheckedOptionalAccessTest, AccessValueInLoop) { 2838 ExpectDiagnosticsFor(R"( 2839 #include "unchecked_optional_access_test.h" 2840 2841 void target() { 2842 $ns::$optional<int> opt = 3; 2843 while (Make<bool>()) { 2844 opt.value(); 2845 } 2846 } 2847 )"); 2848 } 2849 2850 TEST_P(UncheckedOptionalAccessTest, ReassignValueInLoopWithCheckSafe) { 2851 ExpectDiagnosticsFor(R"( 2852 #include "unchecked_optional_access_test.h" 2853 2854 void target() { 2855 $ns::$optional<int> opt = 3; 2856 while (Make<bool>()) { 2857 opt.value(); 2858 2859 opt = Make<$ns::$optional<int>>(); 2860 if (!opt.has_value()) return; 2861 } 2862 } 2863 )"); 2864 } 2865 2866 TEST_P(UncheckedOptionalAccessTest, ReassignValueInLoopNoCheckUnsafe) { 2867 ExpectDiagnosticsFor( 2868 R"( 2869 #include "unchecked_optional_access_test.h" 2870 2871 void target() { 2872 $ns::$optional<int> opt = 3; 2873 while (Make<bool>()) { 2874 opt.value(); // [[unsafe]] 2875 2876 opt = Make<$ns::$optional<int>>(); 2877 } 2878 } 2879 )"); 2880 } 2881 2882 TEST_P(UncheckedOptionalAccessTest, ReassignValueInLoopToUnsetUnsafe) { 2883 ExpectDiagnosticsFor( 2884 R"( 2885 #include "unchecked_optional_access_test.h" 2886 2887 void target() { 2888 $ns::$optional<int> opt = 3; 2889 while (Make<bool>()) 2890 opt = $ns::nullopt; 2891 $ns::$optional<int> opt2 = $ns::nullopt; 2892 if (opt.has_value()) 2893 opt2 = $ns::$optional<int>(3); 2894 opt2.value(); // [[unsafe]] 2895 } 2896 )"); 2897 } 2898 2899 TEST_P(UncheckedOptionalAccessTest, ReassignValueInLoopToSetUnsafe) { 2900 ExpectDiagnosticsFor( 2901 R"( 2902 #include "unchecked_optional_access_test.h" 2903 2904 void target() { 2905 $ns::$optional<int> opt = $ns::nullopt; 2906 while (Make<bool>()) 2907 opt = $ns::$optional<int>(3); 2908 $ns::$optional<int> opt2 = $ns::nullopt; 2909 if (!opt.has_value()) 2910 opt2 = $ns::$optional<int>(3); 2911 opt2.value(); // [[unsafe]] 2912 } 2913 )"); 2914 } 2915 2916 TEST_P(UncheckedOptionalAccessTest, ReassignValueInLoopToUnknownUnsafe) { 2917 ExpectDiagnosticsFor( 2918 R"( 2919 #include "unchecked_optional_access_test.h" 2920 2921 void target() { 2922 $ns::$optional<int> opt = $ns::nullopt; 2923 while (Make<bool>()) 2924 opt = Make<$ns::$optional<int>>(); 2925 $ns::$optional<int> opt2 = $ns::nullopt; 2926 if (!opt.has_value()) 2927 opt2 = $ns::$optional<int>(3); 2928 opt2.value(); // [[unsafe]] 2929 } 2930 )"); 2931 } 2932 2933 TEST_P(UncheckedOptionalAccessTest, ReassignValueInLoopBadConditionUnsafe) { 2934 ExpectDiagnosticsFor( 2935 R"( 2936 #include "unchecked_optional_access_test.h" 2937 2938 void target() { 2939 $ns::$optional<int> opt = 3; 2940 while (Make<bool>()) { 2941 opt.value(); // [[unsafe]] 2942 2943 opt = Make<$ns::$optional<int>>(); 2944 if (!opt.has_value()) continue; 2945 } 2946 } 2947 )"); 2948 } 2949 2950 TEST_P(UncheckedOptionalAccessTest, StructuredBindingsFromStruct) { 2951 ExpectDiagnosticsFor(R"( 2952 #include "unchecked_optional_access_test.h" 2953 2954 struct kv { $ns::$optional<int> opt; int x; }; 2955 int target() { 2956 auto [contents, x] = Make<kv>(); 2957 return contents ? *contents : x; 2958 } 2959 )"); 2960 2961 ExpectDiagnosticsFor(R"( 2962 #include "unchecked_optional_access_test.h" 2963 2964 template <typename T1, typename T2> 2965 struct pair { T1 fst; T2 snd; }; 2966 int target() { 2967 auto [contents, x] = Make<pair<$ns::$optional<int>, int>>(); 2968 return contents ? *contents : x; 2969 } 2970 )"); 2971 } 2972 2973 TEST_P(UncheckedOptionalAccessTest, StructuredBindingsFromTupleLikeType) { 2974 ExpectDiagnosticsFor(R"( 2975 #include "unchecked_optional_access_test.h" 2976 2977 namespace std { 2978 template <class> struct tuple_size; 2979 template <size_t, class> struct tuple_element; 2980 template <class...> class tuple; 2981 2982 template <class... T> 2983 struct tuple_size<tuple<T...>> : integral_constant<size_t, sizeof...(T)> {}; 2984 2985 template <size_t I, class... T> 2986 struct tuple_element<I, tuple<T...>> { 2987 using type = __type_pack_element<I, T...>; 2988 }; 2989 2990 template <class...> class tuple {}; 2991 template <size_t I, class... T> 2992 typename tuple_element<I, tuple<T...>>::type get(tuple<T...>); 2993 } // namespace std 2994 2995 std::tuple<$ns::$optional<const char *>, int> get_opt(); 2996 void target() { 2997 auto [content, ck] = get_opt(); 2998 content ? *content : ""; 2999 } 3000 )"); 3001 } 3002 3003 TEST_P(UncheckedOptionalAccessTest, CtorInitializerNullopt) { 3004 using namespace ast_matchers; 3005 ExpectDiagnosticsFor( 3006 R"( 3007 #include "unchecked_optional_access_test.h" 3008 3009 struct Target { 3010 Target(): opt($ns::nullopt) { 3011 opt.value(); // [[unsafe]] 3012 } 3013 $ns::$optional<int> opt; 3014 }; 3015 )", 3016 cxxConstructorDecl(ofClass(hasName("Target")))); 3017 } 3018 3019 TEST_P(UncheckedOptionalAccessTest, CtorInitializerValue) { 3020 using namespace ast_matchers; 3021 ExpectDiagnosticsFor( 3022 R"( 3023 #include "unchecked_optional_access_test.h" 3024 3025 struct Target { 3026 Target(): opt(3) { 3027 opt.value(); 3028 } 3029 $ns::$optional<int> opt; 3030 }; 3031 )", 3032 cxxConstructorDecl(ofClass(hasName("Target")))); 3033 } 3034 3035 // This is regression test, it shouldn't crash. 3036 TEST_P(UncheckedOptionalAccessTest, Bitfield) { 3037 using namespace ast_matchers; 3038 ExpectDiagnosticsFor( 3039 R"( 3040 #include "unchecked_optional_access_test.h" 3041 struct Dst { 3042 unsigned int n : 1; 3043 }; 3044 void target() { 3045 $ns::$optional<bool> v; 3046 Dst d; 3047 if (v.has_value()) 3048 d.n = v.value(); 3049 } 3050 )"); 3051 } 3052 // FIXME: Add support for: 3053 // - constructors (copy, move) 3054 // - assignment operators (default, copy, move) 3055 // - invalidation (passing optional by non-const reference/pointer) 3056