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 private: 1277 template <typename FuncDeclMatcher> 1278 void ExpectDiagnosticsFor(std::string SourceCode, 1279 FuncDeclMatcher FuncMatcher) { 1280 ReplaceAllOccurrences(SourceCode, "$ns", GetParam().NamespaceName); 1281 ReplaceAllOccurrences(SourceCode, "$optional", GetParam().TypeName); 1282 1283 std::vector<std::pair<std::string, std::string>> Headers; 1284 Headers.emplace_back("cstddef.h", CSDtdDefHeader); 1285 Headers.emplace_back("std_initializer_list.h", StdInitializerListHeader); 1286 Headers.emplace_back("std_string.h", StdStringHeader); 1287 Headers.emplace_back("std_type_traits.h", StdTypeTraitsHeader); 1288 Headers.emplace_back("std_utility.h", StdUtilityHeader); 1289 Headers.emplace_back("std_optional.h", StdOptionalHeader); 1290 Headers.emplace_back("absl_type_traits.h", AbslTypeTraitsHeader); 1291 Headers.emplace_back("absl_optional.h", AbslOptionalHeader); 1292 Headers.emplace_back("base_optional.h", BaseOptionalHeader); 1293 Headers.emplace_back("unchecked_optional_access_test.h", R"( 1294 #include "absl_optional.h" 1295 #include "base_optional.h" 1296 #include "std_initializer_list.h" 1297 #include "std_optional.h" 1298 #include "std_string.h" 1299 #include "std_utility.h" 1300 1301 template <typename T> 1302 T Make(); 1303 )"); 1304 UncheckedOptionalAccessModelOptions Options{ 1305 /*IgnoreSmartPointerDereference=*/true}; 1306 std::vector<SourceLocation> Diagnostics; 1307 llvm::Error Error = checkDataflow<UncheckedOptionalAccessModel>( 1308 AnalysisInputs<UncheckedOptionalAccessModel>( 1309 SourceCode, std::move(FuncMatcher), 1310 [Options](ASTContext &Ctx, Environment &) { 1311 return UncheckedOptionalAccessModel(Ctx, Options); 1312 }) 1313 .withPostVisitCFG( 1314 [&Diagnostics, 1315 Diagnoser = UncheckedOptionalAccessDiagnoser(Options)]( 1316 ASTContext &Ctx, const CFGElement &Elt, 1317 const TypeErasedDataflowAnalysisState &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, UniquePtrToStructWithOptionalField) { 2110 // We suppress diagnostics for values reachable from smart pointers (other 2111 // than `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 struct Foo { 2123 $ns::$optional<int> opt; 2124 }; 2125 2126 void target() { 2127 smart_ptr<Foo> foo; 2128 *foo->opt; 2129 *(*foo).opt; 2130 } 2131 )"); 2132 } 2133 2134 TEST_P(UncheckedOptionalAccessTest, CallReturningOptional) { 2135 ExpectDiagnosticsFor( 2136 R"( 2137 #include "unchecked_optional_access_test.h" 2138 2139 $ns::$optional<int> MakeOpt(); 2140 2141 void target() { 2142 $ns::$optional<int> opt = 0; 2143 opt = MakeOpt(); 2144 opt.value(); // [[unsafe]] 2145 } 2146 )"); 2147 ExpectDiagnosticsFor( 2148 R"( 2149 #include "unchecked_optional_access_test.h" 2150 2151 const $ns::$optional<int>& MakeOpt(); 2152 2153 void target() { 2154 $ns::$optional<int> opt = 0; 2155 opt = MakeOpt(); 2156 opt.value(); // [[unsafe]] 2157 } 2158 )"); 2159 2160 ExpectDiagnosticsFor( 2161 R"( 2162 #include "unchecked_optional_access_test.h" 2163 2164 using IntOpt = $ns::$optional<int>; 2165 IntOpt MakeOpt(); 2166 2167 void target() { 2168 IntOpt opt = 0; 2169 opt = MakeOpt(); 2170 opt.value(); // [[unsafe]] 2171 } 2172 )"); 2173 2174 ExpectDiagnosticsFor( 2175 R"( 2176 #include "unchecked_optional_access_test.h" 2177 2178 using IntOpt = $ns::$optional<int>; 2179 const IntOpt& MakeOpt(); 2180 2181 void target() { 2182 IntOpt opt = 0; 2183 opt = MakeOpt(); 2184 opt.value(); // [[unsafe]] 2185 } 2186 )"); 2187 } 2188 2189 2190 TEST_P(UncheckedOptionalAccessTest, EqualityCheckLeftSet) { 2191 ExpectDiagnosticsFor( 2192 R"( 2193 #include "unchecked_optional_access_test.h" 2194 2195 void target() { 2196 $ns::$optional<int> opt1 = 3; 2197 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2198 2199 if (opt1 == opt2) { 2200 opt2.value(); 2201 } else { 2202 opt2.value(); // [[unsafe]] 2203 } 2204 } 2205 )"); 2206 } 2207 2208 TEST_P(UncheckedOptionalAccessTest, EqualityCheckRightSet) { 2209 ExpectDiagnosticsFor( 2210 R"( 2211 #include "unchecked_optional_access_test.h" 2212 2213 void target() { 2214 $ns::$optional<int> opt1 = 3; 2215 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2216 2217 if (opt2 == opt1) { 2218 opt2.value(); 2219 } else { 2220 opt2.value(); // [[unsafe]] 2221 } 2222 } 2223 )"); 2224 } 2225 2226 TEST_P(UncheckedOptionalAccessTest, EqualityCheckVerifySetAfterEq) { 2227 ExpectDiagnosticsFor( 2228 R"( 2229 #include "unchecked_optional_access_test.h" 2230 2231 void target() { 2232 $ns::$optional<int> opt1 = Make<$ns::$optional<int>>(); 2233 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2234 2235 if (opt1 == opt2) { 2236 if (opt1.has_value()) 2237 opt2.value(); 2238 if (opt2.has_value()) 2239 opt1.value(); 2240 } 2241 } 2242 )"); 2243 } 2244 2245 TEST_P(UncheckedOptionalAccessTest, EqualityCheckLeftUnset) { 2246 ExpectDiagnosticsFor( 2247 R"( 2248 #include "unchecked_optional_access_test.h" 2249 2250 void target() { 2251 $ns::$optional<int> opt1 = $ns::nullopt; 2252 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2253 2254 if (opt1 == opt2) { 2255 opt2.value(); // [[unsafe]] 2256 } else { 2257 opt2.value(); 2258 } 2259 } 2260 )"); 2261 } 2262 2263 TEST_P(UncheckedOptionalAccessTest, EqualityCheckRightUnset) { 2264 ExpectDiagnosticsFor( 2265 R"( 2266 #include "unchecked_optional_access_test.h" 2267 2268 void target() { 2269 $ns::$optional<int> opt1 = $ns::nullopt; 2270 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2271 2272 if (opt2 == opt1) { 2273 opt2.value(); // [[unsafe]] 2274 } else { 2275 opt2.value(); 2276 } 2277 } 2278 )"); 2279 } 2280 2281 TEST_P(UncheckedOptionalAccessTest, EqualityCheckRightNullopt) { 2282 ExpectDiagnosticsFor( 2283 R"( 2284 #include "unchecked_optional_access_test.h" 2285 2286 void target() { 2287 $ns::$optional<int> opt = Make<$ns::$optional<int>>(); 2288 2289 if (opt == $ns::nullopt) { 2290 opt.value(); // [[unsafe]] 2291 } else { 2292 opt.value(); 2293 } 2294 } 2295 )"); 2296 } 2297 2298 TEST_P(UncheckedOptionalAccessTest, EqualityCheckLeftNullopt) { 2299 ExpectDiagnosticsFor( 2300 R"( 2301 #include "unchecked_optional_access_test.h" 2302 2303 void target() { 2304 $ns::$optional<int> opt = Make<$ns::$optional<int>>(); 2305 2306 if ($ns::nullopt == opt) { 2307 opt.value(); // [[unsafe]] 2308 } else { 2309 opt.value(); 2310 } 2311 } 2312 )"); 2313 } 2314 2315 TEST_P(UncheckedOptionalAccessTest, EqualityCheckRightValue) { 2316 ExpectDiagnosticsFor( 2317 R"( 2318 #include "unchecked_optional_access_test.h" 2319 2320 void target() { 2321 $ns::$optional<int> opt = Make<$ns::$optional<int>>(); 2322 2323 if (opt == 3) { 2324 opt.value(); 2325 } else { 2326 opt.value(); // [[unsafe]] 2327 } 2328 } 2329 )"); 2330 } 2331 2332 TEST_P(UncheckedOptionalAccessTest, EqualityCheckLeftValue) { 2333 ExpectDiagnosticsFor( 2334 R"( 2335 #include "unchecked_optional_access_test.h" 2336 2337 void target() { 2338 $ns::$optional<int> opt = Make<$ns::$optional<int>>(); 2339 2340 if (3 == opt) { 2341 opt.value(); 2342 } else { 2343 opt.value(); // [[unsafe]] 2344 } 2345 } 2346 )"); 2347 } 2348 2349 TEST_P(UncheckedOptionalAccessTest, InequalityCheckLeftSet) { 2350 ExpectDiagnosticsFor( 2351 R"( 2352 #include "unchecked_optional_access_test.h" 2353 2354 void target() { 2355 $ns::$optional<int> opt1 = 3; 2356 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2357 2358 if (opt1 != opt2) { 2359 opt2.value(); // [[unsafe]] 2360 } else { 2361 opt2.value(); 2362 } 2363 } 2364 )"); 2365 } 2366 2367 TEST_P(UncheckedOptionalAccessTest, InequalityCheckRightSet) { 2368 ExpectDiagnosticsFor( 2369 R"( 2370 #include "unchecked_optional_access_test.h" 2371 2372 void target() { 2373 $ns::$optional<int> opt1 = 3; 2374 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2375 2376 if (opt2 != opt1) { 2377 opt2.value(); // [[unsafe]] 2378 } else { 2379 opt2.value(); 2380 } 2381 } 2382 )"); 2383 } 2384 2385 TEST_P(UncheckedOptionalAccessTest, InequalityCheckVerifySetAfterEq) { 2386 ExpectDiagnosticsFor( 2387 R"( 2388 #include "unchecked_optional_access_test.h" 2389 2390 void target() { 2391 $ns::$optional<int> opt1 = Make<$ns::$optional<int>>(); 2392 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2393 2394 if (opt1 != opt2) { 2395 if (opt1.has_value()) 2396 opt2.value(); // [[unsafe]] 2397 if (opt2.has_value()) 2398 opt1.value(); // [[unsafe]] 2399 } 2400 } 2401 )"); 2402 } 2403 2404 TEST_P(UncheckedOptionalAccessTest, InequalityCheckLeftUnset) { 2405 ExpectDiagnosticsFor( 2406 R"( 2407 #include "unchecked_optional_access_test.h" 2408 2409 void target() { 2410 $ns::$optional<int> opt1 = $ns::nullopt; 2411 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2412 2413 if (opt1 != opt2) { 2414 opt2.value(); 2415 } else { 2416 opt2.value(); // [[unsafe]] 2417 } 2418 } 2419 )"); 2420 } 2421 2422 TEST_P(UncheckedOptionalAccessTest, InequalityCheckRightUnset) { 2423 ExpectDiagnosticsFor( 2424 R"( 2425 #include "unchecked_optional_access_test.h" 2426 2427 void target() { 2428 $ns::$optional<int> opt1 = $ns::nullopt; 2429 $ns::$optional<int> opt2 = Make<$ns::$optional<int>>(); 2430 2431 if (opt2 != opt1) { 2432 opt2.value(); 2433 } else { 2434 opt2.value(); // [[unsafe]] 2435 } 2436 } 2437 )"); 2438 } 2439 2440 TEST_P(UncheckedOptionalAccessTest, InequalityCheckRightNullopt) { 2441 ExpectDiagnosticsFor( 2442 R"( 2443 #include "unchecked_optional_access_test.h" 2444 2445 void target() { 2446 $ns::$optional<int> opt = Make<$ns::$optional<int>>(); 2447 2448 if (opt != $ns::nullopt) { 2449 opt.value(); 2450 } else { 2451 opt.value(); // [[unsafe]] 2452 } 2453 } 2454 )"); 2455 } 2456 2457 TEST_P(UncheckedOptionalAccessTest, InequalityCheckLeftNullopt) { 2458 ExpectDiagnosticsFor( 2459 R"( 2460 #include "unchecked_optional_access_test.h" 2461 2462 void target() { 2463 $ns::$optional<int> opt = Make<$ns::$optional<int>>(); 2464 2465 if ($ns::nullopt != opt) { 2466 opt.value(); 2467 } else { 2468 opt.value(); // [[unsafe]] 2469 } 2470 } 2471 )"); 2472 } 2473 2474 TEST_P(UncheckedOptionalAccessTest, InequalityCheckRightValue) { 2475 ExpectDiagnosticsFor( 2476 R"( 2477 #include "unchecked_optional_access_test.h" 2478 2479 void target() { 2480 $ns::$optional<int> opt = Make<$ns::$optional<int>>(); 2481 2482 if (opt != 3) { 2483 opt.value(); // [[unsafe]] 2484 } else { 2485 opt.value(); 2486 } 2487 } 2488 )"); 2489 } 2490 2491 TEST_P(UncheckedOptionalAccessTest, InequalityCheckLeftValue) { 2492 ExpectDiagnosticsFor( 2493 R"( 2494 #include "unchecked_optional_access_test.h" 2495 2496 void target() { 2497 $ns::$optional<int> opt = Make<$ns::$optional<int>>(); 2498 2499 if (3 != opt) { 2500 opt.value(); // [[unsafe]] 2501 } else { 2502 opt.value(); 2503 } 2504 } 2505 )"); 2506 } 2507 2508 // Verifies that the model sees through aliases. 2509 TEST_P(UncheckedOptionalAccessTest, WithAlias) { 2510 ExpectDiagnosticsFor( 2511 R"( 2512 #include "unchecked_optional_access_test.h" 2513 2514 template <typename T> 2515 using MyOptional = $ns::$optional<T>; 2516 2517 void target(MyOptional<int> opt) { 2518 opt.value(); // [[unsafe]] 2519 } 2520 )"); 2521 } 2522 2523 TEST_P(UncheckedOptionalAccessTest, OptionalValueOptional) { 2524 // Basic test that nested values are populated. We nest an optional because 2525 // its easy to use in a test, but the type of the nested value shouldn't 2526 // matter. 2527 ExpectDiagnosticsFor( 2528 R"( 2529 #include "unchecked_optional_access_test.h" 2530 2531 using Foo = $ns::$optional<std::string>; 2532 2533 void target($ns::$optional<Foo> foo) { 2534 if (foo && *foo) { 2535 foo->value(); 2536 } 2537 } 2538 )"); 2539 2540 // Mutation is supported for nested values. 2541 ExpectDiagnosticsFor( 2542 R"( 2543 #include "unchecked_optional_access_test.h" 2544 2545 using Foo = $ns::$optional<std::string>; 2546 2547 void target($ns::$optional<Foo> foo) { 2548 if (foo && *foo) { 2549 foo->reset(); 2550 foo->value(); // [[unsafe]] 2551 } 2552 } 2553 )"); 2554 } 2555 2556 // Tests that structs can be nested. We use an optional field because its easy 2557 // to use in a test, but the type of the field shouldn't matter. 2558 TEST_P(UncheckedOptionalAccessTest, OptionalValueStruct) { 2559 ExpectDiagnosticsFor( 2560 R"( 2561 #include "unchecked_optional_access_test.h" 2562 2563 struct Foo { 2564 $ns::$optional<std::string> opt; 2565 }; 2566 2567 void target($ns::$optional<Foo> foo) { 2568 if (foo && foo->opt) { 2569 foo->opt.value(); 2570 } 2571 } 2572 )"); 2573 } 2574 2575 TEST_P(UncheckedOptionalAccessTest, OptionalValueInitialization) { 2576 // FIXME: Fix when to initialize `value`. All unwrapping should be safe in 2577 // this example, but `value` initialization is done multiple times during the 2578 // fixpoint iterations and joining the environment won't correctly merge them. 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, bool b) { 2586 if (!foo.has_value()) return; 2587 if (b) { 2588 if (!foo->has_value()) return; 2589 // We have created `foo.value()`. 2590 foo->value(); 2591 } else { 2592 if (!foo->has_value()) return; 2593 // We have created `foo.value()` again, in a different environment. 2594 foo->value(); 2595 } 2596 // Now we merge the two values. UncheckedOptionalAccessModel::merge() will 2597 // throw away the "value" property. 2598 foo->value(); // [[unsafe]] 2599 } 2600 )"); 2601 } 2602 2603 TEST_P(UncheckedOptionalAccessTest, AssignThroughLvalueReferencePtr) { 2604 ExpectDiagnosticsFor( 2605 R"( 2606 #include "unchecked_optional_access_test.h" 2607 2608 template <typename T> 2609 struct smart_ptr { 2610 typename std::add_lvalue_reference<T>::type operator*() &; 2611 }; 2612 2613 void target() { 2614 smart_ptr<$ns::$optional<float>> x; 2615 *x = $ns::nullopt; 2616 (*x).value(); // [[unsafe]] 2617 } 2618 )"); 2619 } 2620 2621 TEST_P(UncheckedOptionalAccessTest, CorrelatedBranches) { 2622 ExpectDiagnosticsFor(R"code( 2623 #include "unchecked_optional_access_test.h" 2624 2625 void target(bool b, $ns::$optional<int> opt) { 2626 if (b || opt.has_value()) { 2627 if (!b) { 2628 opt.value(); 2629 } 2630 } 2631 } 2632 )code"); 2633 2634 ExpectDiagnosticsFor(R"code( 2635 #include "unchecked_optional_access_test.h" 2636 2637 void target(bool b, $ns::$optional<int> opt) { 2638 if (b && !opt.has_value()) return; 2639 if (b) { 2640 opt.value(); 2641 } 2642 } 2643 )code"); 2644 2645 ExpectDiagnosticsFor( 2646 R"code( 2647 #include "unchecked_optional_access_test.h" 2648 2649 void target(bool b, $ns::$optional<int> opt) { 2650 if (opt.has_value()) b = true; 2651 if (b) { 2652 opt.value(); // [[unsafe]] 2653 } 2654 } 2655 )code"); 2656 2657 ExpectDiagnosticsFor(R"code( 2658 #include "unchecked_optional_access_test.h" 2659 2660 void target(bool b, $ns::$optional<int> opt) { 2661 if (b) return; 2662 if (opt.has_value()) b = true; 2663 if (b) { 2664 opt.value(); 2665 } 2666 } 2667 )code"); 2668 2669 ExpectDiagnosticsFor(R"( 2670 #include "unchecked_optional_access_test.h" 2671 2672 void target(bool b, $ns::$optional<int> opt) { 2673 if (opt.has_value() == b) { 2674 if (b) { 2675 opt.value(); 2676 } 2677 } 2678 } 2679 )"); 2680 2681 ExpectDiagnosticsFor(R"( 2682 #include "unchecked_optional_access_test.h" 2683 2684 void target(bool b, $ns::$optional<int> opt) { 2685 if (opt.has_value() != b) { 2686 if (!b) { 2687 opt.value(); 2688 } 2689 } 2690 } 2691 )"); 2692 2693 ExpectDiagnosticsFor(R"( 2694 #include "unchecked_optional_access_test.h" 2695 2696 void target(bool b) { 2697 $ns::$optional<int> opt1 = $ns::nullopt; 2698 $ns::$optional<int> opt2; 2699 if (b) { 2700 opt2 = $ns::nullopt; 2701 } else { 2702 opt2 = $ns::nullopt; 2703 } 2704 if (opt2.has_value()) { 2705 opt1.value(); 2706 } 2707 } 2708 )"); 2709 2710 // FIXME: Add support for operator==. 2711 // ExpectDiagnosticsFor(R"( 2712 // #include "unchecked_optional_access_test.h" 2713 // 2714 // void target($ns::$optional<int> opt1, $ns::$optional<int> opt2) { 2715 // if (opt1 == opt2) { 2716 // if (opt1.has_value()) { 2717 // opt2.value(); 2718 // } 2719 // } 2720 // } 2721 // )"); 2722 } 2723 2724 TEST_P(UncheckedOptionalAccessTest, JoinDistinctValues) { 2725 ExpectDiagnosticsFor( 2726 R"code( 2727 #include "unchecked_optional_access_test.h" 2728 2729 void target(bool b) { 2730 $ns::$optional<int> opt; 2731 if (b) { 2732 opt = Make<$ns::$optional<int>>(); 2733 } else { 2734 opt = Make<$ns::$optional<int>>(); 2735 } 2736 if (opt.has_value()) { 2737 opt.value(); 2738 } else { 2739 opt.value(); // [[unsafe]] 2740 } 2741 } 2742 )code"); 2743 2744 ExpectDiagnosticsFor(R"code( 2745 #include "unchecked_optional_access_test.h" 2746 2747 void target(bool b) { 2748 $ns::$optional<int> opt; 2749 if (b) { 2750 opt = Make<$ns::$optional<int>>(); 2751 if (!opt.has_value()) return; 2752 } else { 2753 opt = Make<$ns::$optional<int>>(); 2754 if (!opt.has_value()) return; 2755 } 2756 opt.value(); 2757 } 2758 )code"); 2759 2760 ExpectDiagnosticsFor( 2761 R"code( 2762 #include "unchecked_optional_access_test.h" 2763 2764 void target(bool b) { 2765 $ns::$optional<int> opt; 2766 if (b) { 2767 opt = Make<$ns::$optional<int>>(); 2768 if (!opt.has_value()) return; 2769 } else { 2770 opt = Make<$ns::$optional<int>>(); 2771 } 2772 opt.value(); // [[unsafe]] 2773 } 2774 )code"); 2775 2776 ExpectDiagnosticsFor( 2777 R"code( 2778 #include "unchecked_optional_access_test.h" 2779 2780 void target(bool b) { 2781 $ns::$optional<int> opt; 2782 if (b) { 2783 opt = 1; 2784 } else { 2785 opt = 2; 2786 } 2787 opt.value(); 2788 } 2789 )code"); 2790 2791 ExpectDiagnosticsFor( 2792 R"code( 2793 #include "unchecked_optional_access_test.h" 2794 2795 void target(bool b) { 2796 $ns::$optional<int> opt; 2797 if (b) { 2798 opt = 1; 2799 } else { 2800 opt = Make<$ns::$optional<int>>(); 2801 } 2802 opt.value(); // [[unsafe]] 2803 } 2804 )code"); 2805 } 2806 2807 TEST_P(UncheckedOptionalAccessTest, ReassignValueInLoop) { 2808 ExpectDiagnosticsFor(R"( 2809 #include "unchecked_optional_access_test.h" 2810 2811 void target() { 2812 $ns::$optional<int> opt = 3; 2813 while (Make<bool>()) { 2814 opt.value(); 2815 } 2816 } 2817 )"); 2818 2819 ExpectDiagnosticsFor(R"( 2820 #include "unchecked_optional_access_test.h" 2821 2822 void target() { 2823 $ns::$optional<int> opt = 3; 2824 while (Make<bool>()) { 2825 opt.value(); 2826 2827 opt = Make<$ns::$optional<int>>(); 2828 if (!opt.has_value()) return; 2829 } 2830 } 2831 )"); 2832 2833 ExpectDiagnosticsFor( 2834 R"( 2835 #include "unchecked_optional_access_test.h" 2836 2837 void target() { 2838 $ns::$optional<int> opt = 3; 2839 while (Make<bool>()) { 2840 opt.value(); // [[unsafe]] 2841 2842 opt = Make<$ns::$optional<int>>(); 2843 } 2844 } 2845 )"); 2846 2847 ExpectDiagnosticsFor( 2848 R"( 2849 #include "unchecked_optional_access_test.h" 2850 2851 void target() { 2852 $ns::$optional<int> opt = 3; 2853 while (Make<bool>()) { 2854 opt.value(); // [[unsafe]] 2855 2856 opt = Make<$ns::$optional<int>>(); 2857 if (!opt.has_value()) continue; 2858 } 2859 } 2860 )"); 2861 } 2862 2863 // FIXME: Add support for: 2864 // - constructors (copy, move) 2865 // - assignment operators (default, copy, move) 2866 // - invalidation (passing optional by non-const reference/pointer) 2867