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, InPlaceConstructor) { 1502 ExpectDiagnosticsFor(R"( 1503 #include "unchecked_optional_access_test.h" 1504 1505 void target() { 1506 $ns::$optional<int> opt($ns::in_place, 3); 1507 opt.value(); 1508 } 1509 )"); 1510 1511 ExpectDiagnosticsFor(R"( 1512 #include "unchecked_optional_access_test.h" 1513 1514 struct Foo {}; 1515 1516 void target() { 1517 $ns::$optional<Foo> opt($ns::in_place); 1518 opt.value(); 1519 } 1520 )"); 1521 1522 ExpectDiagnosticsFor(R"( 1523 #include "unchecked_optional_access_test.h" 1524 1525 struct Foo { 1526 explicit Foo(int, bool); 1527 }; 1528 1529 void target() { 1530 $ns::$optional<Foo> opt($ns::in_place, 3, false); 1531 opt.value(); 1532 } 1533 )"); 1534 1535 ExpectDiagnosticsFor(R"( 1536 #include "unchecked_optional_access_test.h" 1537 1538 struct Foo { 1539 explicit Foo(std::initializer_list<int>); 1540 }; 1541 1542 void target() { 1543 $ns::$optional<Foo> opt($ns::in_place, {3}); 1544 opt.value(); 1545 } 1546 )"); 1547 } 1548 1549 TEST_P(UncheckedOptionalAccessTest, ValueConstructor) { 1550 ExpectDiagnosticsFor(R"( 1551 #include "unchecked_optional_access_test.h" 1552 1553 void target() { 1554 $ns::$optional<int> opt(21); 1555 opt.value(); 1556 } 1557 )"); 1558 1559 ExpectDiagnosticsFor(R"( 1560 #include "unchecked_optional_access_test.h" 1561 1562 void target() { 1563 $ns::$optional<int> opt = $ns::$optional<int>(21); 1564 opt.value(); 1565 } 1566 )"); 1567 ExpectDiagnosticsFor(R"( 1568 #include "unchecked_optional_access_test.h" 1569 1570 void target() { 1571 $ns::$optional<$ns::$optional<int>> opt(Make<$ns::$optional<int>>()); 1572 opt.value(); 1573 } 1574 )"); 1575 1576 ExpectDiagnosticsFor(R"( 1577 #include "unchecked_optional_access_test.h" 1578 1579 struct MyString { 1580 MyString(const char*); 1581 }; 1582 1583 void target() { 1584 $ns::$optional<MyString> opt("foo"); 1585 opt.value(); 1586 } 1587 )"); 1588 1589 ExpectDiagnosticsFor(R"( 1590 #include "unchecked_optional_access_test.h" 1591 1592 struct Foo {}; 1593 1594 struct Bar { 1595 Bar(const Foo&); 1596 }; 1597 1598 void target() { 1599 $ns::$optional<Bar> opt(Make<Foo>()); 1600 opt.value(); 1601 } 1602 )"); 1603 1604 ExpectDiagnosticsFor(R"( 1605 #include "unchecked_optional_access_test.h" 1606 1607 struct Foo { 1608 explicit Foo(int); 1609 }; 1610 1611 void target() { 1612 $ns::$optional<Foo> opt(3); 1613 opt.value(); 1614 } 1615 )"); 1616 } 1617 1618 TEST_P(UncheckedOptionalAccessTest, ConvertibleOptionalConstructor) { 1619 ExpectDiagnosticsFor( 1620 R"( 1621 #include "unchecked_optional_access_test.h" 1622 1623 struct Foo {}; 1624 1625 struct Bar { 1626 Bar(const Foo&); 1627 }; 1628 1629 void target() { 1630 $ns::$optional<Bar> opt(Make<$ns::$optional<Foo>>()); 1631 opt.value(); // [[unsafe]] 1632 } 1633 )"); 1634 1635 ExpectDiagnosticsFor( 1636 R"( 1637 #include "unchecked_optional_access_test.h" 1638 1639 struct Foo {}; 1640 1641 struct Bar { 1642 explicit Bar(const Foo&); 1643 }; 1644 1645 void target() { 1646 $ns::$optional<Bar> opt(Make<$ns::$optional<Foo>>()); 1647 opt.value(); // [[unsafe]] 1648 } 1649 )"); 1650 1651 ExpectDiagnosticsFor( 1652 R"( 1653 #include "unchecked_optional_access_test.h" 1654 1655 struct Foo {}; 1656 1657 struct Bar { 1658 Bar(const Foo&); 1659 }; 1660 1661 void target() { 1662 $ns::$optional<Foo> opt1 = $ns::nullopt; 1663 $ns::$optional<Bar> opt2(opt1); 1664 opt2.value(); // [[unsafe]] 1665 } 1666 )"); 1667 1668 ExpectDiagnosticsFor(R"( 1669 #include "unchecked_optional_access_test.h" 1670 1671 struct Foo {}; 1672 1673 struct Bar { 1674 Bar(const Foo&); 1675 }; 1676 1677 void target() { 1678 $ns::$optional<Foo> opt1(Make<Foo>()); 1679 $ns::$optional<Bar> opt2(opt1); 1680 opt2.value(); 1681 } 1682 )"); 1683 1684 ExpectDiagnosticsFor(R"( 1685 #include "unchecked_optional_access_test.h" 1686 1687 struct Foo {}; 1688 1689 struct Bar { 1690 explicit Bar(const Foo&); 1691 }; 1692 1693 void target() { 1694 $ns::$optional<Foo> opt1(Make<Foo>()); 1695 $ns::$optional<Bar> opt2(opt1); 1696 opt2.value(); 1697 } 1698 )"); 1699 } 1700 1701 TEST_P(UncheckedOptionalAccessTest, MakeOptional) { 1702 ExpectDiagnosticsFor(R"( 1703 #include "unchecked_optional_access_test.h" 1704 1705 void target() { 1706 $ns::$optional<int> opt = $ns::make_optional(0); 1707 opt.value(); 1708 } 1709 )"); 1710 1711 ExpectDiagnosticsFor(R"( 1712 #include "unchecked_optional_access_test.h" 1713 1714 struct Foo { 1715 Foo(int, int); 1716 }; 1717 1718 void target() { 1719 $ns::$optional<Foo> opt = $ns::make_optional<Foo>(21, 22); 1720 opt.value(); 1721 } 1722 )"); 1723 1724 ExpectDiagnosticsFor(R"( 1725 #include "unchecked_optional_access_test.h" 1726 1727 struct Foo { 1728 constexpr Foo(std::initializer_list<char>); 1729 }; 1730 1731 void target() { 1732 char a = 'a'; 1733 $ns::$optional<Foo> opt = $ns::make_optional<Foo>({a}); 1734 opt.value(); 1735 } 1736 )"); 1737 } 1738 1739 TEST_P(UncheckedOptionalAccessTest, ValueOr) { 1740 ExpectDiagnosticsFor(R"( 1741 #include "unchecked_optional_access_test.h" 1742 1743 void target() { 1744 $ns::$optional<int> opt; 1745 opt.value_or(0); 1746 (void)0; 1747 } 1748 )"); 1749 } 1750 1751 TEST_P(UncheckedOptionalAccessTest, ValueOrComparison) { 1752 // Pointers. 1753 ExpectDiagnosticsFor( 1754 R"code( 1755 #include "unchecked_optional_access_test.h" 1756 1757 void target($ns::$optional<int*> opt) { 1758 if (opt.value_or(nullptr) != nullptr) { 1759 opt.value(); 1760 } else { 1761 opt.value(); // [[unsafe]] 1762 } 1763 } 1764 )code"); 1765 1766 // Integers. 1767 ExpectDiagnosticsFor( 1768 R"code( 1769 #include "unchecked_optional_access_test.h" 1770 1771 void target($ns::$optional<int> opt) { 1772 if (opt.value_or(0) != 0) { 1773 opt.value(); 1774 } else { 1775 opt.value(); // [[unsafe]] 1776 } 1777 } 1778 )code"); 1779 1780 // Strings. 1781 ExpectDiagnosticsFor( 1782 R"code( 1783 #include "unchecked_optional_access_test.h" 1784 1785 void target($ns::$optional<std::string> opt) { 1786 if (!opt.value_or("").empty()) { 1787 opt.value(); 1788 } else { 1789 opt.value(); // [[unsafe]] 1790 } 1791 } 1792 )code"); 1793 1794 ExpectDiagnosticsFor( 1795 R"code( 1796 #include "unchecked_optional_access_test.h" 1797 1798 void target($ns::$optional<std::string> opt) { 1799 if (opt.value_or("") != "") { 1800 opt.value(); 1801 } else { 1802 opt.value(); // [[unsafe]] 1803 } 1804 } 1805 )code"); 1806 1807 // Pointer-to-optional. 1808 // 1809 // FIXME: make `opt` a parameter directly, once we ensure that all `optional` 1810 // values have a `has_value` property. 1811 ExpectDiagnosticsFor( 1812 R"code( 1813 #include "unchecked_optional_access_test.h" 1814 1815 void target($ns::$optional<int> p) { 1816 $ns::$optional<int> *opt = &p; 1817 if (opt->value_or(0) != 0) { 1818 opt->value(); 1819 } else { 1820 opt->value(); // [[unsafe]] 1821 } 1822 } 1823 )code"); 1824 } 1825 1826 TEST_P(UncheckedOptionalAccessTest, Emplace) { 1827 ExpectDiagnosticsFor(R"( 1828 #include "unchecked_optional_access_test.h" 1829 1830 void target() { 1831 $ns::$optional<int> opt; 1832 opt.emplace(0); 1833 opt.value(); 1834 } 1835 )"); 1836 1837 ExpectDiagnosticsFor(R"( 1838 #include "unchecked_optional_access_test.h" 1839 1840 void target($ns::$optional<int> *opt) { 1841 opt->emplace(0); 1842 opt->value(); 1843 } 1844 )"); 1845 1846 // FIXME: Add tests that call `emplace` in conditional branches: 1847 // ExpectDiagnosticsFor( 1848 // R"( 1849 // #include "unchecked_optional_access_test.h" 1850 // 1851 // void target($ns::$optional<int> opt, bool b) { 1852 // if (b) { 1853 // opt.emplace(0); 1854 // } 1855 // if (b) { 1856 // opt.value(); 1857 // } else { 1858 // opt.value(); // [[unsafe]] 1859 // } 1860 // } 1861 // )"); 1862 } 1863 1864 TEST_P(UncheckedOptionalAccessTest, Reset) { 1865 ExpectDiagnosticsFor( 1866 R"( 1867 #include "unchecked_optional_access_test.h" 1868 1869 void target() { 1870 $ns::$optional<int> opt = $ns::make_optional(0); 1871 opt.reset(); 1872 opt.value(); // [[unsafe]] 1873 } 1874 )"); 1875 1876 ExpectDiagnosticsFor( 1877 R"( 1878 #include "unchecked_optional_access_test.h" 1879 1880 void target($ns::$optional<int> &opt) { 1881 if (opt.has_value()) { 1882 opt.reset(); 1883 opt.value(); // [[unsafe]] 1884 } 1885 } 1886 )"); 1887 1888 // FIXME: Add tests that call `reset` in conditional branches: 1889 // ExpectDiagnosticsFor( 1890 // R"( 1891 // #include "unchecked_optional_access_test.h" 1892 // 1893 // void target(bool b) { 1894 // $ns::$optional<int> opt = $ns::make_optional(0); 1895 // if (b) { 1896 // opt.reset(); 1897 // } 1898 // if (b) { 1899 // opt.value(); // [[unsafe]] 1900 // } else { 1901 // opt.value(); 1902 // } 1903 // } 1904 // )"); 1905 } 1906 1907 TEST_P(UncheckedOptionalAccessTest, ValueAssignment) { 1908 ExpectDiagnosticsFor(R"( 1909 #include "unchecked_optional_access_test.h" 1910 1911 struct Foo {}; 1912 1913 void target() { 1914 $ns::$optional<Foo> opt; 1915 opt = Foo(); 1916 opt.value(); 1917 } 1918 )"); 1919 1920 ExpectDiagnosticsFor(R"( 1921 #include "unchecked_optional_access_test.h" 1922 1923 struct Foo {}; 1924 1925 void target() { 1926 $ns::$optional<Foo> opt; 1927 (opt = Foo()).value(); 1928 (void)0; 1929 } 1930 )"); 1931 1932 ExpectDiagnosticsFor(R"( 1933 #include "unchecked_optional_access_test.h" 1934 1935 struct MyString { 1936 MyString(const char*); 1937 }; 1938 1939 void target() { 1940 $ns::$optional<MyString> opt; 1941 opt = "foo"; 1942 opt.value(); 1943 } 1944 )"); 1945 1946 ExpectDiagnosticsFor(R"( 1947 #include "unchecked_optional_access_test.h" 1948 1949 struct MyString { 1950 MyString(const char*); 1951 }; 1952 1953 void target() { 1954 $ns::$optional<MyString> opt; 1955 (opt = "foo").value(); 1956 } 1957 )"); 1958 } 1959 1960 TEST_P(UncheckedOptionalAccessTest, OptionalConversionAssignment) { 1961 ExpectDiagnosticsFor( 1962 R"( 1963 #include "unchecked_optional_access_test.h" 1964 1965 struct Foo {}; 1966 1967 struct Bar { 1968 Bar(const Foo&); 1969 }; 1970 1971 void target() { 1972 $ns::$optional<Foo> opt1 = Foo(); 1973 $ns::$optional<Bar> opt2; 1974 opt2 = opt1; 1975 opt2.value(); 1976 } 1977 )"); 1978 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; 1991 $ns::$optional<Bar> opt2; 1992 if (opt2.has_value()) { 1993 opt2 = opt1; 1994 opt2.value(); // [[unsafe]] 1995 } 1996 } 1997 )"); 1998 1999 ExpectDiagnosticsFor( 2000 R"( 2001 #include "unchecked_optional_access_test.h" 2002 2003 struct Foo {}; 2004 2005 struct Bar { 2006 Bar(const Foo&); 2007 }; 2008 2009 void target() { 2010 $ns::$optional<Foo> opt1 = Foo(); 2011 $ns::$optional<Bar> opt2; 2012 (opt2 = opt1).value(); 2013 (void)0; 2014 } 2015 )"); 2016 } 2017 2018 TEST_P(UncheckedOptionalAccessTest, NulloptAssignment) { 2019 ExpectDiagnosticsFor( 2020 R"( 2021 #include "unchecked_optional_access_test.h" 2022 2023 void target() { 2024 $ns::$optional<int> opt = 3; 2025 opt = $ns::nullopt; 2026 opt.value(); // [[unsafe]] 2027 } 2028 )"); 2029 2030 ExpectDiagnosticsFor( 2031 R"( 2032 #include "unchecked_optional_access_test.h" 2033 2034 void target() { 2035 $ns::$optional<int> opt = 3; 2036 (opt = $ns::nullopt).value(); // [[unsafe]] 2037 } 2038 )"); 2039 } 2040 2041 TEST_P(UncheckedOptionalAccessTest, OptionalSwap) { 2042 ExpectDiagnosticsFor( 2043 R"( 2044 #include "unchecked_optional_access_test.h" 2045 2046 void target() { 2047 $ns::$optional<int> opt1 = $ns::nullopt; 2048 $ns::$optional<int> opt2 = 3; 2049 2050 opt1.swap(opt2); 2051 2052 opt1.value(); 2053 2054 opt2.value(); // [[unsafe]] 2055 } 2056 )"); 2057 2058 ExpectDiagnosticsFor( 2059 R"( 2060 #include "unchecked_optional_access_test.h" 2061 2062 void target() { 2063 $ns::$optional<int> opt1 = $ns::nullopt; 2064 $ns::$optional<int> opt2 = 3; 2065 2066 opt2.swap(opt1); 2067 2068 opt1.value(); 2069 2070 opt2.value(); // [[unsafe]] 2071 } 2072 )"); 2073 } 2074 2075 TEST_P(UncheckedOptionalAccessTest, StdSwap) { 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 std::swap(opt1, opt2); 2085 2086 opt1.value(); 2087 2088 opt2.value(); // [[unsafe]] 2089 } 2090 )"); 2091 2092 ExpectDiagnosticsFor( 2093 R"( 2094 #include "unchecked_optional_access_test.h" 2095 2096 void target() { 2097 $ns::$optional<int> opt1 = $ns::nullopt; 2098 $ns::$optional<int> opt2 = 3; 2099 2100 std::swap(opt2, opt1); 2101 2102 opt1.value(); 2103 2104 opt2.value(); // [[unsafe]] 2105 } 2106 )"); 2107 } 2108 2109 TEST_P(UncheckedOptionalAccessTest, UniquePtrToOptional) { 2110 // We suppress diagnostics for optionals in smart pointers (other than 2111 // `optional` itself). 2112 ExpectDiagnosticsFor( 2113 R"( 2114 #include "unchecked_optional_access_test.h" 2115 2116 template <typename T> 2117 struct smart_ptr { 2118 T& operator*() &; 2119 T* operator->(); 2120 }; 2121 2122 void target() { 2123 smart_ptr<$ns::$optional<bool>> foo; 2124 foo->value(); 2125 (*foo).value(); 2126 } 2127 )"); 2128 } 2129 2130 TEST_P(UncheckedOptionalAccessTest, UniquePtrToStructWithOptionalField) { 2131 // We suppress diagnostics for optional fields reachable from smart pointers 2132 // (other than `optional` itself) through (exactly) one member access. 2133 ExpectDiagnosticsFor( 2134 R"( 2135 #include "unchecked_optional_access_test.h" 2136 2137 template <typename T> 2138 struct smart_ptr { 2139 T& operator*() &; 2140 T* operator->(); 2141 }; 2142 2143 struct Foo { 2144 $ns::$optional<int> opt; 2145 }; 2146 2147 void target() { 2148 smart_ptr<Foo> foo; 2149 *foo->opt; 2150 *(*foo).opt; 2151 } 2152 )"); 2153 } 2154 2155 TEST_P(UncheckedOptionalAccessTest, CallReturningOptional) { 2156 ExpectDiagnosticsFor( 2157 R"( 2158 #include "unchecked_optional_access_test.h" 2159 2160 $ns::$optional<int> MakeOpt(); 2161 2162 void target() { 2163 $ns::$optional<int> opt = 0; 2164 opt = MakeOpt(); 2165 opt.value(); // [[unsafe]] 2166 } 2167 )"); 2168 ExpectDiagnosticsFor( 2169 R"( 2170 #include "unchecked_optional_access_test.h" 2171 2172 const $ns::$optional<int>& MakeOpt(); 2173 2174 void target() { 2175 $ns::$optional<int> opt = 0; 2176 opt = MakeOpt(); 2177 opt.value(); // [[unsafe]] 2178 } 2179 )"); 2180 2181 ExpectDiagnosticsFor( 2182 R"( 2183 #include "unchecked_optional_access_test.h" 2184 2185 using IntOpt = $ns::$optional<int>; 2186 IntOpt MakeOpt(); 2187 2188 void target() { 2189 IntOpt opt = 0; 2190 opt = MakeOpt(); 2191 opt.value(); // [[unsafe]] 2192 } 2193 )"); 2194 2195 ExpectDiagnosticsFor( 2196 R"( 2197 #include "unchecked_optional_access_test.h" 2198 2199 using IntOpt = $ns::$optional<int>; 2200 const IntOpt& MakeOpt(); 2201 2202 void target() { 2203 IntOpt opt = 0; 2204 opt = MakeOpt(); 2205 opt.value(); // [[unsafe]] 2206 } 2207 )"); 2208 } 2209 2210 2211 TEST_P(UncheckedOptionalAccessTest, EqualityCheckLeftSet) { 2212 ExpectDiagnosticsFor( 2213 R"( 2214 #include "unchecked_optional_access_test.h" 2215 2216 void target() { 2217 $ns::$optional<int> opt1 = 3; 2218 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2219 2220 if (opt1 == opt2) { 2221 opt2.value(); 2222 } else { 2223 opt2.value(); // [[unsafe]] 2224 } 2225 } 2226 )"); 2227 } 2228 2229 TEST_P(UncheckedOptionalAccessTest, EqualityCheckRightSet) { 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 (opt2 == opt1) { 2239 opt2.value(); 2240 } else { 2241 opt2.value(); // [[unsafe]] 2242 } 2243 } 2244 )"); 2245 } 2246 2247 TEST_P(UncheckedOptionalAccessTest, EqualityCheckVerifySetAfterEq) { 2248 ExpectDiagnosticsFor( 2249 R"( 2250 #include "unchecked_optional_access_test.h" 2251 2252 void target() { 2253 $ns::$optional<int> opt1 = Make<$ns::$optional<int>>(); 2254 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2255 2256 if (opt1 == opt2) { 2257 if (opt1.has_value()) 2258 opt2.value(); 2259 if (opt2.has_value()) 2260 opt1.value(); 2261 } 2262 } 2263 )"); 2264 } 2265 2266 TEST_P(UncheckedOptionalAccessTest, EqualityCheckLeftUnset) { 2267 ExpectDiagnosticsFor( 2268 R"( 2269 #include "unchecked_optional_access_test.h" 2270 2271 void target() { 2272 $ns::$optional<int> opt1 = $ns::nullopt; 2273 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2274 2275 if (opt1 == opt2) { 2276 opt2.value(); // [[unsafe]] 2277 } else { 2278 opt2.value(); 2279 } 2280 } 2281 )"); 2282 } 2283 2284 TEST_P(UncheckedOptionalAccessTest, EqualityCheckRightUnset) { 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 (opt2 == opt1) { 2294 opt2.value(); // [[unsafe]] 2295 } else { 2296 opt2.value(); 2297 } 2298 } 2299 )"); 2300 } 2301 2302 TEST_P(UncheckedOptionalAccessTest, EqualityCheckRightNullopt) { 2303 ExpectDiagnosticsFor( 2304 R"( 2305 #include "unchecked_optional_access_test.h" 2306 2307 void target() { 2308 $ns::$optional<int> opt = Make<$ns::$optional<int>>(); 2309 2310 if (opt == $ns::nullopt) { 2311 opt.value(); // [[unsafe]] 2312 } else { 2313 opt.value(); 2314 } 2315 } 2316 )"); 2317 } 2318 2319 TEST_P(UncheckedOptionalAccessTest, EqualityCheckLeftNullopt) { 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 ($ns::nullopt == opt) { 2328 opt.value(); // [[unsafe]] 2329 } else { 2330 opt.value(); 2331 } 2332 } 2333 )"); 2334 } 2335 2336 TEST_P(UncheckedOptionalAccessTest, EqualityCheckRightValue) { 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 (opt == 3) { 2345 opt.value(); 2346 } else { 2347 opt.value(); // [[unsafe]] 2348 } 2349 } 2350 )"); 2351 } 2352 2353 TEST_P(UncheckedOptionalAccessTest, EqualityCheckLeftValue) { 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 (3 == opt) { 2362 opt.value(); 2363 } else { 2364 opt.value(); // [[unsafe]] 2365 } 2366 } 2367 )"); 2368 } 2369 2370 TEST_P(UncheckedOptionalAccessTest, InequalityCheckLeftSet) { 2371 ExpectDiagnosticsFor( 2372 R"( 2373 #include "unchecked_optional_access_test.h" 2374 2375 void target() { 2376 $ns::$optional<int> opt1 = 3; 2377 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2378 2379 if (opt1 != opt2) { 2380 opt2.value(); // [[unsafe]] 2381 } else { 2382 opt2.value(); 2383 } 2384 } 2385 )"); 2386 } 2387 2388 TEST_P(UncheckedOptionalAccessTest, InequalityCheckRightSet) { 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 (opt2 != opt1) { 2398 opt2.value(); // [[unsafe]] 2399 } else { 2400 opt2.value(); 2401 } 2402 } 2403 )"); 2404 } 2405 2406 TEST_P(UncheckedOptionalAccessTest, InequalityCheckVerifySetAfterEq) { 2407 ExpectDiagnosticsFor( 2408 R"( 2409 #include "unchecked_optional_access_test.h" 2410 2411 void target() { 2412 $ns::$optional<int> opt1 = Make<$ns::$optional<int>>(); 2413 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2414 2415 if (opt1 != opt2) { 2416 if (opt1.has_value()) 2417 opt2.value(); // [[unsafe]] 2418 if (opt2.has_value()) 2419 opt1.value(); // [[unsafe]] 2420 } 2421 } 2422 )"); 2423 } 2424 2425 TEST_P(UncheckedOptionalAccessTest, InequalityCheckLeftUnset) { 2426 ExpectDiagnosticsFor( 2427 R"( 2428 #include "unchecked_optional_access_test.h" 2429 2430 void target() { 2431 $ns::$optional<int> opt1 = $ns::nullopt; 2432 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2433 2434 if (opt1 != opt2) { 2435 opt2.value(); 2436 } else { 2437 opt2.value(); // [[unsafe]] 2438 } 2439 } 2440 )"); 2441 } 2442 2443 TEST_P(UncheckedOptionalAccessTest, InequalityCheckRightUnset) { 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 (opt2 != opt1) { 2453 opt2.value(); 2454 } else { 2455 opt2.value(); // [[unsafe]] 2456 } 2457 } 2458 )"); 2459 } 2460 2461 TEST_P(UncheckedOptionalAccessTest, InequalityCheckRightNullopt) { 2462 ExpectDiagnosticsFor( 2463 R"( 2464 #include "unchecked_optional_access_test.h" 2465 2466 void target() { 2467 $ns::$optional<int> opt = Make<$ns::$optional<int>>(); 2468 2469 if (opt != $ns::nullopt) { 2470 opt.value(); 2471 } else { 2472 opt.value(); // [[unsafe]] 2473 } 2474 } 2475 )"); 2476 } 2477 2478 TEST_P(UncheckedOptionalAccessTest, InequalityCheckLeftNullopt) { 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 ($ns::nullopt != opt) { 2487 opt.value(); 2488 } else { 2489 opt.value(); // [[unsafe]] 2490 } 2491 } 2492 )"); 2493 } 2494 2495 TEST_P(UncheckedOptionalAccessTest, InequalityCheckRightValue) { 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 (opt != 3) { 2504 opt.value(); // [[unsafe]] 2505 } else { 2506 opt.value(); 2507 } 2508 } 2509 )"); 2510 } 2511 2512 TEST_P(UncheckedOptionalAccessTest, InequalityCheckLeftValue) { 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 (3 != opt) { 2521 opt.value(); // [[unsafe]] 2522 } else { 2523 opt.value(); 2524 } 2525 } 2526 )"); 2527 } 2528 2529 // Verifies that the model sees through aliases. 2530 TEST_P(UncheckedOptionalAccessTest, WithAlias) { 2531 ExpectDiagnosticsFor( 2532 R"( 2533 #include "unchecked_optional_access_test.h" 2534 2535 template <typename T> 2536 using MyOptional = $ns::$optional<T>; 2537 2538 void target(MyOptional<int> opt) { 2539 opt.value(); // [[unsafe]] 2540 } 2541 )"); 2542 } 2543 2544 TEST_P(UncheckedOptionalAccessTest, OptionalValueOptional) { 2545 // Basic test that nested values are populated. We nest an optional because 2546 // its easy to use in a test, but the type of the nested value shouldn't 2547 // matter. 2548 ExpectDiagnosticsFor( 2549 R"( 2550 #include "unchecked_optional_access_test.h" 2551 2552 using Foo = $ns::$optional<std::string>; 2553 2554 void target($ns::$optional<Foo> foo) { 2555 if (foo && *foo) { 2556 foo->value(); 2557 } 2558 } 2559 )"); 2560 2561 // Mutation is supported for nested values. 2562 ExpectDiagnosticsFor( 2563 R"( 2564 #include "unchecked_optional_access_test.h" 2565 2566 using Foo = $ns::$optional<std::string>; 2567 2568 void target($ns::$optional<Foo> foo) { 2569 if (foo && *foo) { 2570 foo->reset(); 2571 foo->value(); // [[unsafe]] 2572 } 2573 } 2574 )"); 2575 } 2576 2577 // Tests that structs can be nested. We use an optional field because its easy 2578 // to use in a test, but the type of the field shouldn't matter. 2579 TEST_P(UncheckedOptionalAccessTest, OptionalValueStruct) { 2580 ExpectDiagnosticsFor( 2581 R"( 2582 #include "unchecked_optional_access_test.h" 2583 2584 struct Foo { 2585 $ns::$optional<std::string> opt; 2586 }; 2587 2588 void target($ns::$optional<Foo> foo) { 2589 if (foo && foo->opt) { 2590 foo->opt.value(); 2591 } 2592 } 2593 )"); 2594 } 2595 2596 TEST_P(UncheckedOptionalAccessTest, OptionalValueInitialization) { 2597 // FIXME: Fix when to initialize `value`. All unwrapping should be safe in 2598 // this example, but `value` initialization is done multiple times during the 2599 // fixpoint iterations and joining the environment won't correctly merge them. 2600 ExpectDiagnosticsFor( 2601 R"( 2602 #include "unchecked_optional_access_test.h" 2603 2604 using Foo = $ns::$optional<std::string>; 2605 2606 void target($ns::$optional<Foo> foo, bool b) { 2607 if (!foo.has_value()) return; 2608 if (b) { 2609 if (!foo->has_value()) return; 2610 // We have created `foo.value()`. 2611 foo->value(); 2612 } else { 2613 if (!foo->has_value()) return; 2614 // We have created `foo.value()` again, in a different environment. 2615 foo->value(); 2616 } 2617 // Now we merge the two values. UncheckedOptionalAccessModel::merge() will 2618 // throw away the "value" property. 2619 foo->value(); // [[unsafe]] 2620 } 2621 )"); 2622 } 2623 2624 // This test is aimed at the core model, not the diagnostic. It is a regression 2625 // test against a crash when using non-trivial smart pointers, like 2626 // `std::unique_ptr`. As such, it doesn't test the access itself, which would be 2627 // ignored regardless because of `IgnoreSmartPointerDereference = true`, above. 2628 TEST_P(UncheckedOptionalAccessTest, AssignThroughLvalueReferencePtr) { 2629 ExpectDiagnosticsFor( 2630 R"( 2631 #include "unchecked_optional_access_test.h" 2632 2633 template <typename T> 2634 struct smart_ptr { 2635 typename std::add_lvalue_reference<T>::type operator*() &; 2636 }; 2637 2638 void target() { 2639 smart_ptr<$ns::$optional<int>> x; 2640 // Verify that this assignment does not crash. 2641 *x = 3; 2642 } 2643 )"); 2644 } 2645 2646 TEST_P(UncheckedOptionalAccessTest, CorrelatedBranches) { 2647 ExpectDiagnosticsFor(R"code( 2648 #include "unchecked_optional_access_test.h" 2649 2650 void target(bool b, $ns::$optional<int> opt) { 2651 if (b || opt.has_value()) { 2652 if (!b) { 2653 opt.value(); 2654 } 2655 } 2656 } 2657 )code"); 2658 2659 ExpectDiagnosticsFor(R"code( 2660 #include "unchecked_optional_access_test.h" 2661 2662 void target(bool b, $ns::$optional<int> opt) { 2663 if (b && !opt.has_value()) return; 2664 if (b) { 2665 opt.value(); 2666 } 2667 } 2668 )code"); 2669 2670 ExpectDiagnosticsFor( 2671 R"code( 2672 #include "unchecked_optional_access_test.h" 2673 2674 void target(bool b, $ns::$optional<int> opt) { 2675 if (opt.has_value()) b = true; 2676 if (b) { 2677 opt.value(); // [[unsafe]] 2678 } 2679 } 2680 )code"); 2681 2682 ExpectDiagnosticsFor(R"code( 2683 #include "unchecked_optional_access_test.h" 2684 2685 void target(bool b, $ns::$optional<int> opt) { 2686 if (b) return; 2687 if (opt.has_value()) b = true; 2688 if (b) { 2689 opt.value(); 2690 } 2691 } 2692 )code"); 2693 2694 ExpectDiagnosticsFor(R"( 2695 #include "unchecked_optional_access_test.h" 2696 2697 void target(bool b, $ns::$optional<int> opt) { 2698 if (opt.has_value() == b) { 2699 if (b) { 2700 opt.value(); 2701 } 2702 } 2703 } 2704 )"); 2705 2706 ExpectDiagnosticsFor(R"( 2707 #include "unchecked_optional_access_test.h" 2708 2709 void target(bool b, $ns::$optional<int> opt) { 2710 if (opt.has_value() != b) { 2711 if (!b) { 2712 opt.value(); 2713 } 2714 } 2715 } 2716 )"); 2717 2718 ExpectDiagnosticsFor(R"( 2719 #include "unchecked_optional_access_test.h" 2720 2721 void target(bool b) { 2722 $ns::$optional<int> opt1 = $ns::nullopt; 2723 $ns::$optional<int> opt2; 2724 if (b) { 2725 opt2 = $ns::nullopt; 2726 } else { 2727 opt2 = $ns::nullopt; 2728 } 2729 if (opt2.has_value()) { 2730 opt1.value(); 2731 } 2732 } 2733 )"); 2734 2735 // FIXME: Add support for operator==. 2736 // ExpectDiagnosticsFor(R"( 2737 // #include "unchecked_optional_access_test.h" 2738 // 2739 // void target($ns::$optional<int> opt1, $ns::$optional<int> opt2) { 2740 // if (opt1 == opt2) { 2741 // if (opt1.has_value()) { 2742 // opt2.value(); 2743 // } 2744 // } 2745 // } 2746 // )"); 2747 } 2748 2749 TEST_P(UncheckedOptionalAccessTest, JoinDistinctValues) { 2750 ExpectDiagnosticsFor( 2751 R"code( 2752 #include "unchecked_optional_access_test.h" 2753 2754 void target(bool b) { 2755 $ns::$optional<int> opt; 2756 if (b) { 2757 opt = Make<$ns::$optional<int>>(); 2758 } else { 2759 opt = Make<$ns::$optional<int>>(); 2760 } 2761 if (opt.has_value()) { 2762 opt.value(); 2763 } else { 2764 opt.value(); // [[unsafe]] 2765 } 2766 } 2767 )code"); 2768 2769 ExpectDiagnosticsFor(R"code( 2770 #include "unchecked_optional_access_test.h" 2771 2772 void target(bool b) { 2773 $ns::$optional<int> opt; 2774 if (b) { 2775 opt = Make<$ns::$optional<int>>(); 2776 if (!opt.has_value()) return; 2777 } else { 2778 opt = Make<$ns::$optional<int>>(); 2779 if (!opt.has_value()) return; 2780 } 2781 opt.value(); 2782 } 2783 )code"); 2784 2785 ExpectDiagnosticsFor( 2786 R"code( 2787 #include "unchecked_optional_access_test.h" 2788 2789 void target(bool b) { 2790 $ns::$optional<int> opt; 2791 if (b) { 2792 opt = Make<$ns::$optional<int>>(); 2793 if (!opt.has_value()) return; 2794 } else { 2795 opt = Make<$ns::$optional<int>>(); 2796 } 2797 opt.value(); // [[unsafe]] 2798 } 2799 )code"); 2800 2801 ExpectDiagnosticsFor( 2802 R"code( 2803 #include "unchecked_optional_access_test.h" 2804 2805 void target(bool b) { 2806 $ns::$optional<int> opt; 2807 if (b) { 2808 opt = 1; 2809 } else { 2810 opt = 2; 2811 } 2812 opt.value(); 2813 } 2814 )code"); 2815 2816 ExpectDiagnosticsFor( 2817 R"code( 2818 #include "unchecked_optional_access_test.h" 2819 2820 void target(bool b) { 2821 $ns::$optional<int> opt; 2822 if (b) { 2823 opt = 1; 2824 } else { 2825 opt = Make<$ns::$optional<int>>(); 2826 } 2827 opt.value(); // [[unsafe]] 2828 } 2829 )code"); 2830 } 2831 2832 TEST_P(UncheckedOptionalAccessTest, ReassignValueInLoop) { 2833 ExpectDiagnosticsFor(R"( 2834 #include "unchecked_optional_access_test.h" 2835 2836 void target() { 2837 $ns::$optional<int> opt = 3; 2838 while (Make<bool>()) { 2839 opt.value(); 2840 } 2841 } 2842 )"); 2843 2844 ExpectDiagnosticsFor(R"( 2845 #include "unchecked_optional_access_test.h" 2846 2847 void target() { 2848 $ns::$optional<int> opt = 3; 2849 while (Make<bool>()) { 2850 opt.value(); 2851 2852 opt = Make<$ns::$optional<int>>(); 2853 if (!opt.has_value()) return; 2854 } 2855 } 2856 )"); 2857 2858 ExpectDiagnosticsFor( 2859 R"( 2860 #include "unchecked_optional_access_test.h" 2861 2862 void target() { 2863 $ns::$optional<int> opt = 3; 2864 while (Make<bool>()) { 2865 opt.value(); // [[unsafe]] 2866 2867 opt = Make<$ns::$optional<int>>(); 2868 } 2869 } 2870 )"); 2871 2872 ExpectDiagnosticsFor( 2873 R"( 2874 #include "unchecked_optional_access_test.h" 2875 2876 void target() { 2877 $ns::$optional<int> opt = 3; 2878 while (Make<bool>()) { 2879 opt.value(); // [[unsafe]] 2880 2881 opt = Make<$ns::$optional<int>>(); 2882 if (!opt.has_value()) continue; 2883 } 2884 } 2885 )"); 2886 } 2887 2888 TEST_P(UncheckedOptionalAccessTest, StructuredBindingsFromStruct) { 2889 ExpectDiagnosticsFor(R"( 2890 #include "unchecked_optional_access_test.h" 2891 2892 struct kv { $ns::$optional<int> opt; int x; }; 2893 int target() { 2894 auto [contents, x] = Make<kv>(); 2895 return contents ? *contents : x; 2896 } 2897 )"); 2898 2899 ExpectDiagnosticsFor(R"( 2900 #include "unchecked_optional_access_test.h" 2901 2902 template <typename T1, typename T2> 2903 struct pair { T1 fst; T2 snd; }; 2904 int target() { 2905 auto [contents, x] = Make<pair<$ns::$optional<int>, int>>(); 2906 return contents ? *contents : x; 2907 } 2908 )"); 2909 } 2910 2911 TEST_P(UncheckedOptionalAccessTest, StructuredBindingsFromTupleLikeType) { 2912 ExpectDiagnosticsFor(R"( 2913 #include "unchecked_optional_access_test.h" 2914 2915 namespace std { 2916 template <class> struct tuple_size; 2917 template <size_t, class> struct tuple_element; 2918 template <class...> class tuple; 2919 2920 template <class... T> 2921 struct tuple_size<tuple<T...>> : integral_constant<size_t, sizeof...(T)> {}; 2922 2923 template <size_t I, class... T> 2924 struct tuple_element<I, tuple<T...>> { 2925 using type = __type_pack_element<I, T...>; 2926 }; 2927 2928 template <class...> class tuple {}; 2929 template <size_t I, class... T> 2930 typename tuple_element<I, tuple<T...>>::type get(tuple<T...>); 2931 } // namespace std 2932 2933 std::tuple<$ns::$optional<const char *>, int> get_opt(); 2934 void target() { 2935 auto [content, ck] = get_opt(); 2936 content ? *content : ""; 2937 } 2938 )"); 2939 } 2940 2941 TEST_P(UncheckedOptionalAccessTest, CtorInitializerNullopt) { 2942 using namespace ast_matchers; 2943 ExpectDiagnosticsFor( 2944 R"( 2945 #include "unchecked_optional_access_test.h" 2946 2947 struct Target { 2948 Target(): opt($ns::nullopt) { 2949 opt.value(); // [[unsafe]] 2950 } 2951 $ns::$optional<int> opt; 2952 }; 2953 )", 2954 cxxConstructorDecl(ofClass(hasName("Target")))); 2955 } 2956 2957 TEST_P(UncheckedOptionalAccessTest, CtorInitializerValue) { 2958 using namespace ast_matchers; 2959 ExpectDiagnosticsFor( 2960 R"( 2961 #include "unchecked_optional_access_test.h" 2962 2963 struct Target { 2964 Target(): opt(3) { 2965 opt.value(); 2966 } 2967 $ns::$optional<int> opt; 2968 }; 2969 )", 2970 cxxConstructorDecl(ofClass(hasName("Target")))); 2971 } 2972 2973 // This is regression test, it shouldn't crash. 2974 TEST_P(UncheckedOptionalAccessTest, Bitfield) { 2975 using namespace ast_matchers; 2976 ExpectDiagnosticsFor( 2977 R"( 2978 #include "unchecked_optional_access_test.h" 2979 struct Dst { 2980 unsigned int n : 1; 2981 }; 2982 void target() { 2983 $ns::$optional<bool> v; 2984 Dst d; 2985 if (v.has_value()) 2986 d.n = v.value(); 2987 } 2988 )"); 2989 } 2990 // FIXME: Add support for: 2991 // - constructors (copy, move) 2992 // - assignment operators (default, copy, move) 2993 // - invalidation (passing optional by non-const reference/pointer) 2994