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