xref: /llvm-project/clang/unittests/Analysis/FlowSensitive/UncheckedOptionalAccessModelTest.cpp (revision cd22e0dc9d0b5487eb2d54dd028a2aa439627159) 
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/Basic/SourceLocation.h"
15 #include "clang/Tooling/Tooling.h"
16 #include "llvm/ADT/DenseSet.h"
17 #include "llvm/ADT/STLExtras.h"
18 #include "llvm/Support/Error.h"
19 #include "gmock/gmock.h"
20 #include "gtest/gtest.h"
21 #include <optional>
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 // Verifies that similarly-named types are ignored.
1357 TEST_P(UncheckedOptionalAccessTest, NonTrackedOptionalType) {
1358   ExpectDiagnosticsFor(
1359       R"(
1360     namespace other {
1361     namespace $ns {
1362     template <typename T>
1363     struct $optional {
1364       T value();
1365     };
1366     }
1367 
1368     void target($ns::$optional<int> opt) {
1369       opt.value();
1370     }
1371     }
1372   )");
1373 }
1374 
1375 TEST_P(UncheckedOptionalAccessTest, EmptyFunctionBody) {
1376   ExpectDiagnosticsFor(R"(
1377     void target() {
1378       (void)0;
1379     }
1380   )");
1381 }
1382 
1383 TEST_P(UncheckedOptionalAccessTest, UnwrapUsingValueNoCheck) {
1384   ExpectDiagnosticsFor(
1385       R"(
1386     #include "unchecked_optional_access_test.h"
1387 
1388     void target($ns::$optional<int> opt) {
1389       opt.value(); // [[unsafe]]
1390     }
1391   )");
1392 
1393   ExpectDiagnosticsFor(
1394       R"(
1395     #include "unchecked_optional_access_test.h"
1396 
1397     void target($ns::$optional<int> opt) {
1398       std::move(opt).value(); // [[unsafe]]
1399     }
1400   )");
1401 }
1402 
1403 TEST_P(UncheckedOptionalAccessTest, UnwrapUsingOperatorStarNoCheck) {
1404   ExpectDiagnosticsFor(
1405       R"(
1406     #include "unchecked_optional_access_test.h"
1407 
1408     void target($ns::$optional<int> opt) {
1409       *opt; // [[unsafe]]
1410     }
1411   )");
1412 
1413   ExpectDiagnosticsFor(
1414       R"(
1415     #include "unchecked_optional_access_test.h"
1416 
1417     void target($ns::$optional<int> opt) {
1418       *std::move(opt); // [[unsafe]]
1419     }
1420   )");
1421 }
1422 
1423 TEST_P(UncheckedOptionalAccessTest, UnwrapUsingOperatorArrowNoCheck) {
1424   ExpectDiagnosticsFor(
1425       R"(
1426     #include "unchecked_optional_access_test.h"
1427 
1428     struct Foo {
1429       void foo();
1430     };
1431 
1432     void target($ns::$optional<Foo> opt) {
1433       opt->foo(); // [[unsafe]]
1434     }
1435   )");
1436 
1437   ExpectDiagnosticsFor(
1438       R"(
1439     #include "unchecked_optional_access_test.h"
1440 
1441     struct Foo {
1442       void foo();
1443     };
1444 
1445     void target($ns::$optional<Foo> opt) {
1446       std::move(opt)->foo(); // [[unsafe]]
1447     }
1448   )");
1449 }
1450 
1451 TEST_P(UncheckedOptionalAccessTest, HasValueCheck) {
1452   ExpectDiagnosticsFor(R"(
1453     #include "unchecked_optional_access_test.h"
1454 
1455     void target($ns::$optional<int> opt) {
1456       if (opt.has_value()) {
1457         opt.value();
1458       }
1459     }
1460   )");
1461 }
1462 
1463 TEST_P(UncheckedOptionalAccessTest, OperatorBoolCheck) {
1464   ExpectDiagnosticsFor(R"(
1465     #include "unchecked_optional_access_test.h"
1466 
1467     void target($ns::$optional<int> opt) {
1468       if (opt) {
1469         opt.value();
1470       }
1471     }
1472   )");
1473 }
1474 
1475 TEST_P(UncheckedOptionalAccessTest, UnwrapFunctionCallResultNoCheck) {
1476   ExpectDiagnosticsFor(
1477       R"(
1478     #include "unchecked_optional_access_test.h"
1479 
1480     void target() {
1481       Make<$ns::$optional<int>>().value(); // [[unsafe]]
1482       (void)0;
1483     }
1484   )");
1485 
1486   ExpectDiagnosticsFor(
1487       R"(
1488     #include "unchecked_optional_access_test.h"
1489 
1490     void target($ns::$optional<int> opt) {
1491       std::move(opt).value(); // [[unsafe]]
1492     }
1493   )");
1494 }
1495 
1496 TEST_P(UncheckedOptionalAccessTest, DefaultConstructor) {
1497   ExpectDiagnosticsFor(
1498       R"(
1499     #include "unchecked_optional_access_test.h"
1500 
1501     void target() {
1502       $ns::$optional<int> opt;
1503       opt.value(); // [[unsafe]]
1504     }
1505   )");
1506 }
1507 
1508 TEST_P(UncheckedOptionalAccessTest, NulloptConstructor) {
1509   ExpectDiagnosticsFor(
1510       R"(
1511     #include "unchecked_optional_access_test.h"
1512 
1513     void target() {
1514       $ns::$optional<int> opt($ns::nullopt);
1515       opt.value(); // [[unsafe]]
1516     }
1517   )");
1518 }
1519 
1520 TEST_P(UncheckedOptionalAccessTest, NulloptConstructorWithSugaredType) {
1521   ExpectDiagnosticsFor(
1522       R"(
1523     #include "unchecked_optional_access_test.h"
1524     template <typename T>
1525     using wrapper = T;
1526 
1527     template <typename T>
1528     wrapper<T> wrap(T);
1529 
1530     void target() {
1531       $ns::$optional<int> opt(wrap($ns::nullopt));
1532       opt.value(); // [[unsafe]]
1533     }
1534   )");
1535 }
1536 
1537 TEST_P(UncheckedOptionalAccessTest, InPlaceConstructor) {
1538   ExpectDiagnosticsFor(R"(
1539     #include "unchecked_optional_access_test.h"
1540 
1541     void target() {
1542       $ns::$optional<int> opt($ns::in_place, 3);
1543       opt.value();
1544     }
1545   )");
1546 
1547   ExpectDiagnosticsFor(R"(
1548     #include "unchecked_optional_access_test.h"
1549 
1550     struct Foo {};
1551 
1552     void target() {
1553       $ns::$optional<Foo> opt($ns::in_place);
1554       opt.value();
1555     }
1556   )");
1557 
1558   ExpectDiagnosticsFor(R"(
1559     #include "unchecked_optional_access_test.h"
1560 
1561     struct Foo {
1562       explicit Foo(int, bool);
1563     };
1564 
1565     void target() {
1566       $ns::$optional<Foo> opt($ns::in_place, 3, false);
1567       opt.value();
1568     }
1569   )");
1570 
1571   ExpectDiagnosticsFor(R"(
1572     #include "unchecked_optional_access_test.h"
1573 
1574     struct Foo {
1575       explicit Foo(std::initializer_list<int>);
1576     };
1577 
1578     void target() {
1579       $ns::$optional<Foo> opt($ns::in_place, {3});
1580       opt.value();
1581     }
1582   )");
1583 }
1584 
1585 TEST_P(UncheckedOptionalAccessTest, ValueConstructor) {
1586   ExpectDiagnosticsFor(R"(
1587     #include "unchecked_optional_access_test.h"
1588 
1589     void target() {
1590       $ns::$optional<int> opt(21);
1591       opt.value();
1592     }
1593   )");
1594 
1595   ExpectDiagnosticsFor(R"(
1596     #include "unchecked_optional_access_test.h"
1597 
1598     void target() {
1599       $ns::$optional<int> opt = $ns::$optional<int>(21);
1600       opt.value();
1601     }
1602   )");
1603   ExpectDiagnosticsFor(R"(
1604     #include "unchecked_optional_access_test.h"
1605 
1606     void target() {
1607       $ns::$optional<$ns::$optional<int>> opt(Make<$ns::$optional<int>>());
1608       opt.value();
1609     }
1610   )");
1611 
1612   ExpectDiagnosticsFor(R"(
1613     #include "unchecked_optional_access_test.h"
1614 
1615     struct MyString {
1616       MyString(const char*);
1617     };
1618 
1619     void target() {
1620       $ns::$optional<MyString> opt("foo");
1621       opt.value();
1622     }
1623   )");
1624 
1625   ExpectDiagnosticsFor(R"(
1626     #include "unchecked_optional_access_test.h"
1627 
1628     struct Foo {};
1629 
1630     struct Bar {
1631       Bar(const Foo&);
1632     };
1633 
1634     void target() {
1635       $ns::$optional<Bar> opt(Make<Foo>());
1636       opt.value();
1637     }
1638   )");
1639 
1640   ExpectDiagnosticsFor(R"(
1641     #include "unchecked_optional_access_test.h"
1642 
1643     struct Foo {
1644       explicit Foo(int);
1645     };
1646 
1647     void target() {
1648       $ns::$optional<Foo> opt(3);
1649       opt.value();
1650     }
1651   )");
1652 }
1653 
1654 TEST_P(UncheckedOptionalAccessTest, ConvertibleOptionalConstructor) {
1655   ExpectDiagnosticsFor(
1656       R"(
1657     #include "unchecked_optional_access_test.h"
1658 
1659     struct Foo {};
1660 
1661     struct Bar {
1662       Bar(const Foo&);
1663     };
1664 
1665     void target() {
1666       $ns::$optional<Bar> opt(Make<$ns::$optional<Foo>>());
1667       opt.value(); // [[unsafe]]
1668     }
1669   )");
1670 
1671   ExpectDiagnosticsFor(
1672       R"(
1673     #include "unchecked_optional_access_test.h"
1674 
1675     struct Foo {};
1676 
1677     struct Bar {
1678       explicit Bar(const Foo&);
1679     };
1680 
1681     void target() {
1682       $ns::$optional<Bar> opt(Make<$ns::$optional<Foo>>());
1683       opt.value(); // [[unsafe]]
1684     }
1685   )");
1686 
1687   ExpectDiagnosticsFor(
1688       R"(
1689     #include "unchecked_optional_access_test.h"
1690 
1691     struct Foo {};
1692 
1693     struct Bar {
1694       Bar(const Foo&);
1695     };
1696 
1697     void target() {
1698       $ns::$optional<Foo> opt1 = $ns::nullopt;
1699       $ns::$optional<Bar> opt2(opt1);
1700       opt2.value(); // [[unsafe]]
1701     }
1702   )");
1703 
1704   ExpectDiagnosticsFor(R"(
1705     #include "unchecked_optional_access_test.h"
1706 
1707     struct Foo {};
1708 
1709     struct Bar {
1710       Bar(const Foo&);
1711     };
1712 
1713     void target() {
1714       $ns::$optional<Foo> opt1(Make<Foo>());
1715       $ns::$optional<Bar> opt2(opt1);
1716       opt2.value();
1717     }
1718   )");
1719 
1720   ExpectDiagnosticsFor(R"(
1721     #include "unchecked_optional_access_test.h"
1722 
1723     struct Foo {};
1724 
1725     struct Bar {
1726       explicit Bar(const Foo&);
1727     };
1728 
1729     void target() {
1730       $ns::$optional<Foo> opt1(Make<Foo>());
1731       $ns::$optional<Bar> opt2(opt1);
1732       opt2.value();
1733     }
1734   )");
1735 }
1736 
1737 TEST_P(UncheckedOptionalAccessTest, MakeOptional) {
1738   ExpectDiagnosticsFor(R"(
1739     #include "unchecked_optional_access_test.h"
1740 
1741     void target() {
1742       $ns::$optional<int> opt = $ns::make_optional(0);
1743       opt.value();
1744     }
1745   )");
1746 
1747   ExpectDiagnosticsFor(R"(
1748     #include "unchecked_optional_access_test.h"
1749 
1750     struct Foo {
1751       Foo(int, int);
1752     };
1753 
1754     void target() {
1755       $ns::$optional<Foo> opt = $ns::make_optional<Foo>(21, 22);
1756       opt.value();
1757     }
1758   )");
1759 
1760   ExpectDiagnosticsFor(R"(
1761     #include "unchecked_optional_access_test.h"
1762 
1763     struct Foo {
1764       constexpr Foo(std::initializer_list<char>);
1765     };
1766 
1767     void target() {
1768       char a = 'a';
1769       $ns::$optional<Foo> opt = $ns::make_optional<Foo>({a});
1770       opt.value();
1771     }
1772   )");
1773 }
1774 
1775 TEST_P(UncheckedOptionalAccessTest, ValueOr) {
1776   ExpectDiagnosticsFor(R"(
1777     #include "unchecked_optional_access_test.h"
1778 
1779     void target() {
1780       $ns::$optional<int> opt;
1781       opt.value_or(0);
1782       (void)0;
1783     }
1784   )");
1785 }
1786 
1787 TEST_P(UncheckedOptionalAccessTest, ValueOrComparison) {
1788   // Pointers.
1789   ExpectDiagnosticsFor(
1790       R"code(
1791     #include "unchecked_optional_access_test.h"
1792 
1793     void target($ns::$optional<int*> opt) {
1794       if (opt.value_or(nullptr) != nullptr) {
1795         opt.value();
1796       } else {
1797         opt.value(); // [[unsafe]]
1798       }
1799     }
1800   )code");
1801 
1802   // Integers.
1803   ExpectDiagnosticsFor(
1804       R"code(
1805     #include "unchecked_optional_access_test.h"
1806 
1807     void target($ns::$optional<int> opt) {
1808       if (opt.value_or(0) != 0) {
1809         opt.value();
1810       } else {
1811         opt.value(); // [[unsafe]]
1812       }
1813     }
1814   )code");
1815 
1816   // Strings.
1817   ExpectDiagnosticsFor(
1818       R"code(
1819     #include "unchecked_optional_access_test.h"
1820 
1821     void target($ns::$optional<std::string> opt) {
1822       if (!opt.value_or("").empty()) {
1823         opt.value();
1824       } else {
1825         opt.value(); // [[unsafe]]
1826       }
1827     }
1828   )code");
1829 
1830   ExpectDiagnosticsFor(
1831       R"code(
1832     #include "unchecked_optional_access_test.h"
1833 
1834     void target($ns::$optional<std::string> opt) {
1835       if (opt.value_or("") != "") {
1836         opt.value();
1837       } else {
1838         opt.value(); // [[unsafe]]
1839       }
1840     }
1841   )code");
1842 
1843   // Pointer-to-optional.
1844   //
1845   // FIXME: make `opt` a parameter directly, once we ensure that all `optional`
1846   // values have a `has_value` property.
1847   ExpectDiagnosticsFor(
1848       R"code(
1849     #include "unchecked_optional_access_test.h"
1850 
1851     void target($ns::$optional<int> p) {
1852       $ns::$optional<int> *opt = &p;
1853       if (opt->value_or(0) != 0) {
1854         opt->value();
1855       } else {
1856         opt->value(); // [[unsafe]]
1857       }
1858     }
1859   )code");
1860 }
1861 
1862 TEST_P(UncheckedOptionalAccessTest, Emplace) {
1863   ExpectDiagnosticsFor(R"(
1864     #include "unchecked_optional_access_test.h"
1865 
1866     void target() {
1867       $ns::$optional<int> opt;
1868       opt.emplace(0);
1869       opt.value();
1870     }
1871   )");
1872 
1873   ExpectDiagnosticsFor(R"(
1874     #include "unchecked_optional_access_test.h"
1875 
1876     void target($ns::$optional<int> *opt) {
1877       opt->emplace(0);
1878       opt->value();
1879     }
1880   )");
1881 
1882   // FIXME: Add tests that call `emplace` in conditional branches:
1883   //  ExpectDiagnosticsFor(
1884   //      R"(
1885   //    #include "unchecked_optional_access_test.h"
1886   //
1887   //    void target($ns::$optional<int> opt, bool b) {
1888   //      if (b) {
1889   //        opt.emplace(0);
1890   //      }
1891   //      if (b) {
1892   //        opt.value();
1893   //      } else {
1894   //        opt.value(); // [[unsafe]]
1895   //      }
1896   //    }
1897   //  )");
1898 }
1899 
1900 TEST_P(UncheckedOptionalAccessTest, Reset) {
1901   ExpectDiagnosticsFor(
1902       R"(
1903     #include "unchecked_optional_access_test.h"
1904 
1905     void target() {
1906       $ns::$optional<int> opt = $ns::make_optional(0);
1907       opt.reset();
1908       opt.value(); // [[unsafe]]
1909     }
1910   )");
1911 
1912   ExpectDiagnosticsFor(
1913       R"(
1914     #include "unchecked_optional_access_test.h"
1915 
1916     void target($ns::$optional<int> &opt) {
1917       if (opt.has_value()) {
1918         opt.reset();
1919         opt.value(); // [[unsafe]]
1920       }
1921     }
1922   )");
1923 
1924   // FIXME: Add tests that call `reset` in conditional branches:
1925   //  ExpectDiagnosticsFor(
1926   //      R"(
1927   //    #include "unchecked_optional_access_test.h"
1928   //
1929   //    void target(bool b) {
1930   //      $ns::$optional<int> opt = $ns::make_optional(0);
1931   //      if (b) {
1932   //        opt.reset();
1933   //      }
1934   //      if (b) {
1935   //        opt.value(); // [[unsafe]]
1936   //      } else {
1937   //        opt.value();
1938   //      }
1939   //    }
1940   //  )");
1941 }
1942 
1943 TEST_P(UncheckedOptionalAccessTest, ValueAssignment) {
1944   ExpectDiagnosticsFor(R"(
1945     #include "unchecked_optional_access_test.h"
1946 
1947     struct Foo {};
1948 
1949     void target() {
1950       $ns::$optional<Foo> opt;
1951       opt = Foo();
1952       opt.value();
1953     }
1954   )");
1955 
1956   ExpectDiagnosticsFor(R"(
1957     #include "unchecked_optional_access_test.h"
1958 
1959     struct Foo {};
1960 
1961     void target() {
1962       $ns::$optional<Foo> opt;
1963       (opt = Foo()).value();
1964       (void)0;
1965     }
1966   )");
1967 
1968   ExpectDiagnosticsFor(R"(
1969     #include "unchecked_optional_access_test.h"
1970 
1971     struct MyString {
1972       MyString(const char*);
1973     };
1974 
1975     void target() {
1976       $ns::$optional<MyString> opt;
1977       opt = "foo";
1978       opt.value();
1979     }
1980   )");
1981 
1982   ExpectDiagnosticsFor(R"(
1983     #include "unchecked_optional_access_test.h"
1984 
1985     struct MyString {
1986       MyString(const char*);
1987     };
1988 
1989     void target() {
1990       $ns::$optional<MyString> opt;
1991       (opt = "foo").value();
1992     }
1993   )");
1994 }
1995 
1996 TEST_P(UncheckedOptionalAccessTest, OptionalConversionAssignment) {
1997   ExpectDiagnosticsFor(
1998       R"(
1999     #include "unchecked_optional_access_test.h"
2000 
2001     struct Foo {};
2002 
2003     struct Bar {
2004       Bar(const Foo&);
2005     };
2006 
2007     void target() {
2008       $ns::$optional<Foo> opt1 = Foo();
2009       $ns::$optional<Bar> opt2;
2010       opt2 = opt1;
2011       opt2.value();
2012     }
2013   )");
2014 
2015   ExpectDiagnosticsFor(
2016       R"(
2017     #include "unchecked_optional_access_test.h"
2018 
2019     struct Foo {};
2020 
2021     struct Bar {
2022       Bar(const Foo&);
2023     };
2024 
2025     void target() {
2026       $ns::$optional<Foo> opt1;
2027       $ns::$optional<Bar> opt2;
2028       if (opt2.has_value()) {
2029         opt2 = opt1;
2030         opt2.value(); // [[unsafe]]
2031       }
2032     }
2033   )");
2034 
2035   ExpectDiagnosticsFor(
2036       R"(
2037     #include "unchecked_optional_access_test.h"
2038 
2039     struct Foo {};
2040 
2041     struct Bar {
2042       Bar(const Foo&);
2043     };
2044 
2045     void target() {
2046       $ns::$optional<Foo> opt1 = Foo();
2047       $ns::$optional<Bar> opt2;
2048       (opt2 = opt1).value();
2049       (void)0;
2050     }
2051   )");
2052 }
2053 
2054 TEST_P(UncheckedOptionalAccessTest, NulloptAssignment) {
2055   ExpectDiagnosticsFor(
2056       R"(
2057     #include "unchecked_optional_access_test.h"
2058 
2059     void target() {
2060       $ns::$optional<int> opt = 3;
2061       opt = $ns::nullopt;
2062       opt.value(); // [[unsafe]]
2063     }
2064   )");
2065 
2066   ExpectDiagnosticsFor(
2067       R"(
2068     #include "unchecked_optional_access_test.h"
2069 
2070     void target() {
2071       $ns::$optional<int> opt = 3;
2072       (opt = $ns::nullopt).value(); // [[unsafe]]
2073     }
2074   )");
2075 }
2076 
2077 TEST_P(UncheckedOptionalAccessTest, OptionalSwap) {
2078   ExpectDiagnosticsFor(
2079       R"(
2080     #include "unchecked_optional_access_test.h"
2081 
2082     void target() {
2083       $ns::$optional<int> opt1 = $ns::nullopt;
2084       $ns::$optional<int> opt2 = 3;
2085 
2086       opt1.swap(opt2);
2087 
2088       opt1.value();
2089 
2090       opt2.value(); // [[unsafe]]
2091     }
2092   )");
2093 
2094   ExpectDiagnosticsFor(
2095       R"(
2096     #include "unchecked_optional_access_test.h"
2097 
2098     void target() {
2099       $ns::$optional<int> opt1 = $ns::nullopt;
2100       $ns::$optional<int> opt2 = 3;
2101 
2102       opt2.swap(opt1);
2103 
2104       opt1.value();
2105 
2106       opt2.value(); // [[unsafe]]
2107     }
2108   )");
2109 }
2110 
2111 TEST_P(UncheckedOptionalAccessTest, StdSwap) {
2112   ExpectDiagnosticsFor(
2113       R"(
2114     #include "unchecked_optional_access_test.h"
2115 
2116     void target() {
2117       $ns::$optional<int> opt1 = $ns::nullopt;
2118       $ns::$optional<int> opt2 = 3;
2119 
2120       std::swap(opt1, opt2);
2121 
2122       opt1.value();
2123 
2124       opt2.value(); // [[unsafe]]
2125     }
2126   )");
2127 
2128   ExpectDiagnosticsFor(
2129       R"(
2130     #include "unchecked_optional_access_test.h"
2131 
2132     void target() {
2133       $ns::$optional<int> opt1 = $ns::nullopt;
2134       $ns::$optional<int> opt2 = 3;
2135 
2136       std::swap(opt2, opt1);
2137 
2138       opt1.value();
2139 
2140       opt2.value(); // [[unsafe]]
2141     }
2142   )");
2143 }
2144 
2145 TEST_P(UncheckedOptionalAccessTest, SwapUnmodeledLocLeft) {
2146   ExpectDiagnosticsFor(
2147       R"(
2148     #include "unchecked_optional_access_test.h"
2149 
2150     struct L { $ns::$optional<int> hd; L* tl; };
2151 
2152     void target() {
2153       $ns::$optional<int> foo = 3;
2154       L bar;
2155 
2156       // Any `tl` beyond the first is not modeled.
2157       bar.tl->tl->hd.swap(foo);
2158 
2159       bar.tl->tl->hd.value(); // [[unsafe]]
2160       foo.value(); // [[unsafe]]
2161     }
2162   )");
2163 }
2164 
2165 TEST_P(UncheckedOptionalAccessTest, SwapUnmodeledLocRight) {
2166   ExpectDiagnosticsFor(
2167       R"(
2168     #include "unchecked_optional_access_test.h"
2169 
2170     struct L { $ns::$optional<int> hd; L* tl; };
2171 
2172     void target() {
2173       $ns::$optional<int> foo = 3;
2174       L bar;
2175 
2176       // Any `tl` beyond the first is not modeled.
2177       foo.swap(bar.tl->tl->hd);
2178 
2179       bar.tl->tl->hd.value(); // [[unsafe]]
2180       foo.value(); // [[unsafe]]
2181     }
2182   )");
2183 }
2184 
2185 TEST_P(UncheckedOptionalAccessTest, SwapUnmodeledValueLeftSet) {
2186   ExpectDiagnosticsFor(
2187       R"(
2188     #include "unchecked_optional_access_test.h"
2189 
2190     struct S { int x; };
2191     struct A { $ns::$optional<S> late; };
2192     struct B { A f3; };
2193     struct C { B f2; };
2194     struct D { C f1; };
2195 
2196     void target() {
2197       $ns::$optional<S> foo = S{3};
2198       D bar;
2199 
2200       bar.f1.f2.f3.late.swap(foo);
2201 
2202       bar.f1.f2.f3.late.value();
2203       foo.value(); // [[unsafe]]
2204     }
2205   )");
2206 }
2207 
2208 TEST_P(UncheckedOptionalAccessTest, SwapUnmodeledValueLeftUnset) {
2209   ExpectDiagnosticsFor(
2210       R"(
2211     #include "unchecked_optional_access_test.h"
2212 
2213     struct S { int x; };
2214     struct A { $ns::$optional<S> late; };
2215     struct B { A f3; };
2216     struct C { B f2; };
2217     struct D { C f1; };
2218 
2219     void target() {
2220       $ns::$optional<S> foo;
2221       D bar;
2222 
2223       bar.f1.f2.f3.late.swap(foo);
2224 
2225       bar.f1.f2.f3.late.value(); // [[unsafe]]
2226       foo.value(); // [[unsafe]]
2227     }
2228   )");
2229 }
2230 
2231 // fixme: use recursion instead of depth.
2232 TEST_P(UncheckedOptionalAccessTest, SwapUnmodeledValueRightSet) {
2233   ExpectDiagnosticsFor(
2234       R"(
2235     #include "unchecked_optional_access_test.h"
2236 
2237     struct S { int x; };
2238     struct A { $ns::$optional<S> late; };
2239     struct B { A f3; };
2240     struct C { B f2; };
2241     struct D { C f1; };
2242 
2243     void target() {
2244       $ns::$optional<S> foo = S{3};
2245       D bar;
2246 
2247       foo.swap(bar.f1.f2.f3.late);
2248 
2249       bar.f1.f2.f3.late.value();
2250       foo.value(); // [[unsafe]]
2251     }
2252   )");
2253 }
2254 
2255 TEST_P(UncheckedOptionalAccessTest, SwapUnmodeledValueRightUnset) {
2256   ExpectDiagnosticsFor(
2257       R"(
2258     #include "unchecked_optional_access_test.h"
2259 
2260     struct S { int x; };
2261     struct A { $ns::$optional<S> late; };
2262     struct B { A f3; };
2263     struct C { B f2; };
2264     struct D { C f1; };
2265 
2266     void target() {
2267       $ns::$optional<S> foo;
2268       D bar;
2269 
2270       foo.swap(bar.f1.f2.f3.late);
2271 
2272       bar.f1.f2.f3.late.value(); // [[unsafe]]
2273       foo.value(); // [[unsafe]]
2274     }
2275   )");
2276 }
2277 
2278 TEST_P(UncheckedOptionalAccessTest, UniquePtrToOptional) {
2279   // We suppress diagnostics for optionals in smart pointers (other than
2280   // `optional` itself).
2281   ExpectDiagnosticsFor(
2282       R"(
2283     #include "unchecked_optional_access_test.h"
2284 
2285     template <typename T>
2286     struct smart_ptr {
2287       T& operator*() &;
2288       T* operator->();
2289     };
2290 
2291     void target() {
2292       smart_ptr<$ns::$optional<bool>> foo;
2293       foo->value();
2294       (*foo).value();
2295     }
2296   )");
2297 }
2298 
2299 TEST_P(UncheckedOptionalAccessTest, UniquePtrToStructWithOptionalField) {
2300   // We suppress diagnostics for optional fields reachable from smart pointers
2301   // (other than `optional` itself) through (exactly) one member access.
2302   ExpectDiagnosticsFor(
2303       R"(
2304     #include "unchecked_optional_access_test.h"
2305 
2306     template <typename T>
2307     struct smart_ptr {
2308       T& operator*() &;
2309       T* operator->();
2310     };
2311 
2312     struct Foo {
2313       $ns::$optional<int> opt;
2314     };
2315 
2316     void target() {
2317       smart_ptr<Foo> foo;
2318       *foo->opt;
2319       *(*foo).opt;
2320     }
2321   )");
2322 }
2323 
2324 TEST_P(UncheckedOptionalAccessTest, CallReturningOptional) {
2325   ExpectDiagnosticsFor(
2326       R"(
2327     #include "unchecked_optional_access_test.h"
2328 
2329     $ns::$optional<int> MakeOpt();
2330 
2331     void target() {
2332       $ns::$optional<int> opt = 0;
2333       opt = MakeOpt();
2334       opt.value(); // [[unsafe]]
2335     }
2336   )");
2337   ExpectDiagnosticsFor(
2338       R"(
2339     #include "unchecked_optional_access_test.h"
2340 
2341     const $ns::$optional<int>& MakeOpt();
2342 
2343     void target() {
2344       $ns::$optional<int> opt = 0;
2345       opt = MakeOpt();
2346       opt.value(); // [[unsafe]]
2347     }
2348   )");
2349 
2350   ExpectDiagnosticsFor(
2351       R"(
2352     #include "unchecked_optional_access_test.h"
2353 
2354     using IntOpt = $ns::$optional<int>;
2355     IntOpt MakeOpt();
2356 
2357     void target() {
2358       IntOpt opt = 0;
2359       opt = MakeOpt();
2360       opt.value(); // [[unsafe]]
2361     }
2362   )");
2363 
2364   ExpectDiagnosticsFor(
2365       R"(
2366     #include "unchecked_optional_access_test.h"
2367 
2368     using IntOpt = $ns::$optional<int>;
2369     const IntOpt& MakeOpt();
2370 
2371     void target() {
2372       IntOpt opt = 0;
2373       opt = MakeOpt();
2374       opt.value(); // [[unsafe]]
2375     }
2376   )");
2377 }
2378 
2379 
2380 TEST_P(UncheckedOptionalAccessTest, EqualityCheckLeftSet) {
2381   ExpectDiagnosticsFor(
2382       R"(
2383     #include "unchecked_optional_access_test.h"
2384 
2385     void target() {
2386       $ns::$optional<int> opt1 = 3;
2387       $ns::$optional<int> opt2 = Make<$ns::$optional<int>>();
2388 
2389       if (opt1 == opt2) {
2390         opt2.value();
2391       } else {
2392         opt2.value(); // [[unsafe]]
2393       }
2394     }
2395   )");
2396 }
2397 
2398 TEST_P(UncheckedOptionalAccessTest, EqualityCheckRightSet) {
2399   ExpectDiagnosticsFor(
2400       R"(
2401     #include "unchecked_optional_access_test.h"
2402 
2403     void target() {
2404       $ns::$optional<int> opt1 = 3;
2405       $ns::$optional<int> opt2 = Make<$ns::$optional<int>>();
2406 
2407       if (opt2 == opt1) {
2408         opt2.value();
2409       } else {
2410         opt2.value(); // [[unsafe]]
2411       }
2412     }
2413   )");
2414 }
2415 
2416 TEST_P(UncheckedOptionalAccessTest, EqualityCheckVerifySetAfterEq) {
2417   ExpectDiagnosticsFor(
2418       R"(
2419     #include "unchecked_optional_access_test.h"
2420 
2421     void target() {
2422       $ns::$optional<int> opt1 = Make<$ns::$optional<int>>();
2423       $ns::$optional<int> opt2 = Make<$ns::$optional<int>>();
2424 
2425       if (opt1 == opt2) {
2426         if (opt1.has_value())
2427           opt2.value();
2428         if (opt2.has_value())
2429           opt1.value();
2430       }
2431     }
2432   )");
2433 }
2434 
2435 TEST_P(UncheckedOptionalAccessTest, EqualityCheckLeftUnset) {
2436   ExpectDiagnosticsFor(
2437       R"(
2438     #include "unchecked_optional_access_test.h"
2439 
2440     void target() {
2441       $ns::$optional<int> opt1 = $ns::nullopt;
2442       $ns::$optional<int> opt2 = Make<$ns::$optional<int>>();
2443 
2444       if (opt1 == opt2) {
2445         opt2.value(); // [[unsafe]]
2446       } else {
2447         opt2.value();
2448       }
2449     }
2450   )");
2451 }
2452 
2453 TEST_P(UncheckedOptionalAccessTest, EqualityCheckRightUnset) {
2454   ExpectDiagnosticsFor(
2455       R"(
2456     #include "unchecked_optional_access_test.h"
2457 
2458     void target() {
2459       $ns::$optional<int> opt1 = $ns::nullopt;
2460       $ns::$optional<int> opt2 = Make<$ns::$optional<int>>();
2461 
2462       if (opt2 == opt1) {
2463         opt2.value(); // [[unsafe]]
2464       } else {
2465         opt2.value();
2466       }
2467     }
2468   )");
2469 }
2470 
2471 TEST_P(UncheckedOptionalAccessTest, EqualityCheckRightNullopt) {
2472   ExpectDiagnosticsFor(
2473       R"(
2474     #include "unchecked_optional_access_test.h"
2475 
2476     void target() {
2477       $ns::$optional<int> opt = Make<$ns::$optional<int>>();
2478 
2479       if (opt == $ns::nullopt) {
2480         opt.value(); // [[unsafe]]
2481       } else {
2482         opt.value();
2483       }
2484     }
2485   )");
2486 }
2487 
2488 TEST_P(UncheckedOptionalAccessTest, EqualityCheckLeftNullopt) {
2489   ExpectDiagnosticsFor(
2490       R"(
2491     #include "unchecked_optional_access_test.h"
2492 
2493     void target() {
2494       $ns::$optional<int> opt = Make<$ns::$optional<int>>();
2495 
2496       if ($ns::nullopt == opt) {
2497         opt.value(); // [[unsafe]]
2498       } else {
2499         opt.value();
2500       }
2501     }
2502   )");
2503 }
2504 
2505 TEST_P(UncheckedOptionalAccessTest, EqualityCheckRightValue) {
2506   ExpectDiagnosticsFor(
2507       R"(
2508     #include "unchecked_optional_access_test.h"
2509 
2510     void target() {
2511       $ns::$optional<int> opt = Make<$ns::$optional<int>>();
2512 
2513       if (opt == 3) {
2514         opt.value();
2515       } else {
2516         opt.value(); // [[unsafe]]
2517       }
2518     }
2519   )");
2520 }
2521 
2522 TEST_P(UncheckedOptionalAccessTest, EqualityCheckLeftValue) {
2523   ExpectDiagnosticsFor(
2524       R"(
2525     #include "unchecked_optional_access_test.h"
2526 
2527     void target() {
2528       $ns::$optional<int> opt = Make<$ns::$optional<int>>();
2529 
2530       if (3 == opt) {
2531         opt.value();
2532       } else {
2533         opt.value(); // [[unsafe]]
2534       }
2535     }
2536   )");
2537 }
2538 
2539 TEST_P(UncheckedOptionalAccessTest, InequalityCheckLeftSet) {
2540   ExpectDiagnosticsFor(
2541       R"(
2542     #include "unchecked_optional_access_test.h"
2543 
2544     void target() {
2545       $ns::$optional<int> opt1 = 3;
2546       $ns::$optional<int> opt2 = Make<$ns::$optional<int>>();
2547 
2548       if (opt1 != opt2) {
2549         opt2.value(); // [[unsafe]]
2550       } else {
2551         opt2.value();
2552       }
2553     }
2554   )");
2555 }
2556 
2557 TEST_P(UncheckedOptionalAccessTest, InequalityCheckRightSet) {
2558   ExpectDiagnosticsFor(
2559       R"(
2560     #include "unchecked_optional_access_test.h"
2561 
2562     void target() {
2563       $ns::$optional<int> opt1 = 3;
2564       $ns::$optional<int> opt2 = Make<$ns::$optional<int>>();
2565 
2566       if (opt2 != opt1) {
2567         opt2.value(); // [[unsafe]]
2568       } else {
2569         opt2.value();
2570       }
2571     }
2572   )");
2573 }
2574 
2575 TEST_P(UncheckedOptionalAccessTest, InequalityCheckVerifySetAfterEq) {
2576   ExpectDiagnosticsFor(
2577       R"(
2578     #include "unchecked_optional_access_test.h"
2579 
2580     void target() {
2581       $ns::$optional<int> opt1 = Make<$ns::$optional<int>>();
2582       $ns::$optional<int> opt2 = Make<$ns::$optional<int>>();
2583 
2584       if (opt1 != opt2) {
2585         if (opt1.has_value())
2586           opt2.value(); // [[unsafe]]
2587         if (opt2.has_value())
2588           opt1.value(); // [[unsafe]]
2589       }
2590     }
2591   )");
2592 }
2593 
2594 TEST_P(UncheckedOptionalAccessTest, InequalityCheckLeftUnset) {
2595   ExpectDiagnosticsFor(
2596       R"(
2597     #include "unchecked_optional_access_test.h"
2598 
2599     void target() {
2600       $ns::$optional<int> opt1 = $ns::nullopt;
2601       $ns::$optional<int> opt2 = Make<$ns::$optional<int>>();
2602 
2603       if (opt1 != opt2) {
2604         opt2.value();
2605       } else {
2606         opt2.value(); // [[unsafe]]
2607       }
2608     }
2609   )");
2610 }
2611 
2612 TEST_P(UncheckedOptionalAccessTest, InequalityCheckRightUnset) {
2613   ExpectDiagnosticsFor(
2614       R"(
2615     #include "unchecked_optional_access_test.h"
2616 
2617     void target() {
2618       $ns::$optional<int> opt1 = $ns::nullopt;
2619       $ns::$optional<int> opt2 = Make<$ns::$optional<int>>();
2620 
2621       if (opt2 != opt1) {
2622         opt2.value();
2623       } else {
2624         opt2.value(); // [[unsafe]]
2625       }
2626     }
2627   )");
2628 }
2629 
2630 TEST_P(UncheckedOptionalAccessTest, InequalityCheckRightNullopt) {
2631   ExpectDiagnosticsFor(
2632       R"(
2633     #include "unchecked_optional_access_test.h"
2634 
2635     void target() {
2636       $ns::$optional<int> opt = Make<$ns::$optional<int>>();
2637 
2638       if (opt != $ns::nullopt) {
2639         opt.value();
2640       } else {
2641         opt.value(); // [[unsafe]]
2642       }
2643     }
2644   )");
2645 }
2646 
2647 TEST_P(UncheckedOptionalAccessTest, InequalityCheckLeftNullopt) {
2648   ExpectDiagnosticsFor(
2649       R"(
2650     #include "unchecked_optional_access_test.h"
2651 
2652     void target() {
2653       $ns::$optional<int> opt = Make<$ns::$optional<int>>();
2654 
2655       if ($ns::nullopt != opt) {
2656         opt.value();
2657       } else {
2658         opt.value(); // [[unsafe]]
2659       }
2660     }
2661   )");
2662 }
2663 
2664 TEST_P(UncheckedOptionalAccessTest, InequalityCheckRightValue) {
2665   ExpectDiagnosticsFor(
2666       R"(
2667     #include "unchecked_optional_access_test.h"
2668 
2669     void target() {
2670       $ns::$optional<int> opt = Make<$ns::$optional<int>>();
2671 
2672       if (opt != 3) {
2673         opt.value(); // [[unsafe]]
2674       } else {
2675         opt.value();
2676       }
2677     }
2678   )");
2679 }
2680 
2681 TEST_P(UncheckedOptionalAccessTest, InequalityCheckLeftValue) {
2682   ExpectDiagnosticsFor(
2683       R"(
2684     #include "unchecked_optional_access_test.h"
2685 
2686     void target() {
2687       $ns::$optional<int> opt = Make<$ns::$optional<int>>();
2688 
2689       if (3 != opt) {
2690         opt.value(); // [[unsafe]]
2691       } else {
2692         opt.value();
2693       }
2694     }
2695   )");
2696 }
2697 
2698 // Verifies that the model sees through aliases.
2699 TEST_P(UncheckedOptionalAccessTest, WithAlias) {
2700   ExpectDiagnosticsFor(
2701       R"(
2702     #include "unchecked_optional_access_test.h"
2703 
2704     template <typename T>
2705     using MyOptional = $ns::$optional<T>;
2706 
2707     void target(MyOptional<int> opt) {
2708       opt.value(); // [[unsafe]]
2709     }
2710   )");
2711 }
2712 
2713 TEST_P(UncheckedOptionalAccessTest, OptionalValueOptional) {
2714   // Basic test that nested values are populated.  We nest an optional because
2715   // its easy to use in a test, but the type of the nested value shouldn't
2716   // matter.
2717   ExpectDiagnosticsFor(
2718       R"(
2719     #include "unchecked_optional_access_test.h"
2720 
2721     using Foo = $ns::$optional<std::string>;
2722 
2723     void target($ns::$optional<Foo> foo) {
2724       if (foo && *foo) {
2725         foo->value();
2726       }
2727     }
2728   )");
2729 
2730   // Mutation is supported for nested values.
2731   ExpectDiagnosticsFor(
2732       R"(
2733     #include "unchecked_optional_access_test.h"
2734 
2735     using Foo = $ns::$optional<std::string>;
2736 
2737     void target($ns::$optional<Foo> foo) {
2738       if (foo && *foo) {
2739         foo->reset();
2740         foo->value(); // [[unsafe]]
2741       }
2742     }
2743   )");
2744 }
2745 
2746 // Tests that structs can be nested. We use an optional field because its easy
2747 // to use in a test, but the type of the field shouldn't matter.
2748 TEST_P(UncheckedOptionalAccessTest, OptionalValueStruct) {
2749   ExpectDiagnosticsFor(
2750       R"(
2751     #include "unchecked_optional_access_test.h"
2752 
2753     struct Foo {
2754       $ns::$optional<std::string> opt;
2755     };
2756 
2757     void target($ns::$optional<Foo> foo) {
2758       if (foo && foo->opt) {
2759         foo->opt.value();
2760       }
2761     }
2762   )");
2763 }
2764 
2765 TEST_P(UncheckedOptionalAccessTest, OptionalValueInitialization) {
2766   // FIXME: Fix when to initialize `value`. All unwrapping should be safe in
2767   // this example, but `value` initialization is done multiple times during the
2768   // fixpoint iterations and joining the environment won't correctly merge them.
2769   ExpectDiagnosticsFor(
2770       R"(
2771     #include "unchecked_optional_access_test.h"
2772 
2773     using Foo = $ns::$optional<std::string>;
2774 
2775     void target($ns::$optional<Foo> foo, bool b) {
2776       if (!foo.has_value()) return;
2777       if (b) {
2778         if (!foo->has_value()) return;
2779         // We have created `foo.value()`.
2780         foo->value();
2781       } else {
2782         if (!foo->has_value()) return;
2783         // We have created `foo.value()` again, in a different environment.
2784         foo->value();
2785       }
2786       // Now we merge the two values. UncheckedOptionalAccessModel::merge() will
2787       // throw away the "value" property.
2788       foo->value(); // [[unsafe]]
2789     }
2790   )");
2791 }
2792 
2793 // This test is aimed at the core model, not the diagnostic. It is a regression
2794 // test against a crash when using non-trivial smart pointers, like
2795 // `std::unique_ptr`. As such, it doesn't test the access itself, which would be
2796 // ignored regardless because of `IgnoreSmartPointerDereference = true`, above.
2797 TEST_P(UncheckedOptionalAccessTest, AssignThroughLvalueReferencePtr) {
2798   ExpectDiagnosticsFor(
2799       R"(
2800     #include "unchecked_optional_access_test.h"
2801 
2802     template <typename T>
2803     struct smart_ptr {
2804       typename std::add_lvalue_reference<T>::type operator*() &;
2805     };
2806 
2807     void target() {
2808       smart_ptr<$ns::$optional<int>> x;
2809       // Verify that this assignment does not crash.
2810       *x = 3;
2811     }
2812   )");
2813 }
2814 
2815 TEST_P(UncheckedOptionalAccessTest, CorrelatedBranches) {
2816   ExpectDiagnosticsFor(R"code(
2817     #include "unchecked_optional_access_test.h"
2818 
2819     void target(bool b, $ns::$optional<int> opt) {
2820       if (b || opt.has_value()) {
2821         if (!b) {
2822           opt.value();
2823         }
2824       }
2825     }
2826   )code");
2827 
2828   ExpectDiagnosticsFor(R"code(
2829     #include "unchecked_optional_access_test.h"
2830 
2831     void target(bool b, $ns::$optional<int> opt) {
2832       if (b && !opt.has_value()) return;
2833       if (b) {
2834         opt.value();
2835       }
2836     }
2837   )code");
2838 
2839   ExpectDiagnosticsFor(
2840       R"code(
2841     #include "unchecked_optional_access_test.h"
2842 
2843     void target(bool b, $ns::$optional<int> opt) {
2844       if (opt.has_value()) b = true;
2845       if (b) {
2846         opt.value(); // [[unsafe]]
2847       }
2848     }
2849   )code");
2850 
2851   ExpectDiagnosticsFor(R"code(
2852     #include "unchecked_optional_access_test.h"
2853 
2854     void target(bool b, $ns::$optional<int> opt) {
2855       if (b) return;
2856       if (opt.has_value()) b = true;
2857       if (b) {
2858         opt.value();
2859       }
2860     }
2861   )code");
2862 
2863   ExpectDiagnosticsFor(R"(
2864     #include "unchecked_optional_access_test.h"
2865 
2866     void target(bool b, $ns::$optional<int> opt) {
2867       if (opt.has_value() == b) {
2868         if (b) {
2869           opt.value();
2870         }
2871       }
2872     }
2873   )");
2874 
2875   ExpectDiagnosticsFor(R"(
2876     #include "unchecked_optional_access_test.h"
2877 
2878     void target(bool b, $ns::$optional<int> opt) {
2879       if (opt.has_value() != b) {
2880         if (!b) {
2881           opt.value();
2882         }
2883       }
2884     }
2885   )");
2886 
2887   ExpectDiagnosticsFor(R"(
2888     #include "unchecked_optional_access_test.h"
2889 
2890     void target(bool b) {
2891       $ns::$optional<int> opt1 = $ns::nullopt;
2892       $ns::$optional<int> opt2;
2893       if (b) {
2894         opt2 = $ns::nullopt;
2895       } else {
2896         opt2 = $ns::nullopt;
2897       }
2898       if (opt2.has_value()) {
2899         opt1.value();
2900       }
2901     }
2902   )");
2903 }
2904 
2905 TEST_P(UncheckedOptionalAccessTest, JoinDistinctValues) {
2906   ExpectDiagnosticsFor(
2907       R"code(
2908     #include "unchecked_optional_access_test.h"
2909 
2910     void target(bool b) {
2911       $ns::$optional<int> opt;
2912       if (b) {
2913         opt = Make<$ns::$optional<int>>();
2914       } else {
2915         opt = Make<$ns::$optional<int>>();
2916       }
2917       if (opt.has_value()) {
2918         opt.value();
2919       } else {
2920         opt.value(); // [[unsafe]]
2921       }
2922     }
2923   )code");
2924 
2925   ExpectDiagnosticsFor(R"code(
2926     #include "unchecked_optional_access_test.h"
2927 
2928     void target(bool b) {
2929       $ns::$optional<int> opt;
2930       if (b) {
2931         opt = Make<$ns::$optional<int>>();
2932         if (!opt.has_value()) return;
2933       } else {
2934         opt = Make<$ns::$optional<int>>();
2935         if (!opt.has_value()) return;
2936       }
2937       opt.value();
2938     }
2939   )code");
2940 
2941   ExpectDiagnosticsFor(
2942       R"code(
2943     #include "unchecked_optional_access_test.h"
2944 
2945     void target(bool b) {
2946       $ns::$optional<int> opt;
2947       if (b) {
2948         opt = Make<$ns::$optional<int>>();
2949         if (!opt.has_value()) return;
2950       } else {
2951         opt = Make<$ns::$optional<int>>();
2952       }
2953       opt.value(); // [[unsafe]]
2954     }
2955   )code");
2956 
2957   ExpectDiagnosticsFor(
2958       R"code(
2959     #include "unchecked_optional_access_test.h"
2960 
2961     void target(bool b) {
2962       $ns::$optional<int> opt;
2963       if (b) {
2964         opt = 1;
2965       } else {
2966         opt = 2;
2967       }
2968       opt.value();
2969     }
2970   )code");
2971 
2972   ExpectDiagnosticsFor(
2973       R"code(
2974     #include "unchecked_optional_access_test.h"
2975 
2976     void target(bool b) {
2977       $ns::$optional<int> opt;
2978       if (b) {
2979         opt = 1;
2980       } else {
2981         opt = Make<$ns::$optional<int>>();
2982       }
2983       opt.value(); // [[unsafe]]
2984     }
2985   )code");
2986 }
2987 
2988 TEST_P(UncheckedOptionalAccessTest, AccessValueInLoop) {
2989   ExpectDiagnosticsFor(R"(
2990     #include "unchecked_optional_access_test.h"
2991 
2992     void target() {
2993       $ns::$optional<int> opt = 3;
2994       while (Make<bool>()) {
2995         opt.value();
2996       }
2997     }
2998   )");
2999 }
3000 
3001 TEST_P(UncheckedOptionalAccessTest, ReassignValueInLoopWithCheckSafe) {
3002   ExpectDiagnosticsFor(R"(
3003     #include "unchecked_optional_access_test.h"
3004 
3005     void target() {
3006       $ns::$optional<int> opt = 3;
3007       while (Make<bool>()) {
3008         opt.value();
3009 
3010         opt = Make<$ns::$optional<int>>();
3011         if (!opt.has_value()) return;
3012       }
3013     }
3014   )");
3015 }
3016 
3017 TEST_P(UncheckedOptionalAccessTest, ReassignValueInLoopNoCheckUnsafe) {
3018   ExpectDiagnosticsFor(
3019       R"(
3020     #include "unchecked_optional_access_test.h"
3021 
3022     void target() {
3023       $ns::$optional<int> opt = 3;
3024       while (Make<bool>()) {
3025         opt.value(); // [[unsafe]]
3026 
3027         opt = Make<$ns::$optional<int>>();
3028       }
3029     }
3030   )");
3031 }
3032 
3033 TEST_P(UncheckedOptionalAccessTest, ReassignValueInLoopToUnsetUnsafe) {
3034   ExpectDiagnosticsFor(
3035       R"(
3036     #include "unchecked_optional_access_test.h"
3037 
3038     void target() {
3039       $ns::$optional<int> opt = 3;
3040       while (Make<bool>())
3041         opt = $ns::nullopt;
3042       $ns::$optional<int> opt2 = $ns::nullopt;
3043       if (opt.has_value())
3044         opt2 = $ns::$optional<int>(3);
3045       opt2.value(); // [[unsafe]]
3046     }
3047   )");
3048 }
3049 
3050 TEST_P(UncheckedOptionalAccessTest, ReassignValueInLoopToSetUnsafe) {
3051   ExpectDiagnosticsFor(
3052       R"(
3053     #include "unchecked_optional_access_test.h"
3054 
3055     void target() {
3056       $ns::$optional<int> opt = $ns::nullopt;
3057       while (Make<bool>())
3058         opt = $ns::$optional<int>(3);
3059       $ns::$optional<int> opt2 = $ns::nullopt;
3060       if (!opt.has_value())
3061         opt2 = $ns::$optional<int>(3);
3062       opt2.value(); // [[unsafe]]
3063     }
3064   )");
3065 }
3066 
3067 TEST_P(UncheckedOptionalAccessTest, ReassignValueInLoopToUnknownUnsafe) {
3068   ExpectDiagnosticsFor(
3069       R"(
3070     #include "unchecked_optional_access_test.h"
3071 
3072     void target() {
3073       $ns::$optional<int> opt = $ns::nullopt;
3074       while (Make<bool>())
3075         opt = Make<$ns::$optional<int>>();
3076       $ns::$optional<int> opt2 = $ns::nullopt;
3077       if (!opt.has_value())
3078         opt2 = $ns::$optional<int>(3);
3079       opt2.value(); // [[unsafe]]
3080     }
3081   )");
3082 }
3083 
3084 TEST_P(UncheckedOptionalAccessTest, ReassignValueInLoopBadConditionUnsafe) {
3085   ExpectDiagnosticsFor(
3086       R"(
3087     #include "unchecked_optional_access_test.h"
3088 
3089     void target() {
3090       $ns::$optional<int> opt = 3;
3091       while (Make<bool>()) {
3092         opt.value(); // [[unsafe]]
3093 
3094         opt = Make<$ns::$optional<int>>();
3095         if (!opt.has_value()) continue;
3096       }
3097     }
3098   )");
3099 }
3100 
3101 TEST_P(UncheckedOptionalAccessTest, StructuredBindingsFromStruct) {
3102   ExpectDiagnosticsFor(R"(
3103     #include "unchecked_optional_access_test.h"
3104 
3105     struct kv { $ns::$optional<int> opt; int x; };
3106     int target() {
3107       auto [contents, x] = Make<kv>();
3108       return contents ? *contents : x;
3109     }
3110   )");
3111 
3112   ExpectDiagnosticsFor(R"(
3113     #include "unchecked_optional_access_test.h"
3114 
3115     template <typename T1, typename T2>
3116     struct pair { T1 fst;  T2 snd; };
3117     int target() {
3118       auto [contents, x] = Make<pair<$ns::$optional<int>, int>>();
3119       return contents ? *contents : x;
3120     }
3121   )");
3122 }
3123 
3124 TEST_P(UncheckedOptionalAccessTest, StructuredBindingsFromTupleLikeType) {
3125   ExpectDiagnosticsFor(R"(
3126     #include "unchecked_optional_access_test.h"
3127 
3128     namespace std {
3129     template <class> struct tuple_size;
3130     template <size_t, class> struct tuple_element;
3131     template <class...> class tuple;
3132 
3133     template <class... T>
3134     struct tuple_size<tuple<T...>> : integral_constant<size_t, sizeof...(T)> {};
3135 
3136     template <size_t I, class... T>
3137     struct tuple_element<I, tuple<T...>> {
3138       using type =  __type_pack_element<I, T...>;
3139     };
3140 
3141     template <class...> class tuple {};
3142     template <size_t I, class... T>
3143     typename tuple_element<I, tuple<T...>>::type get(tuple<T...>);
3144     } // namespace std
3145 
3146     std::tuple<$ns::$optional<const char *>, int> get_opt();
3147     void target() {
3148       auto [content, ck] = get_opt();
3149       content ? *content : "";
3150     }
3151   )");
3152 }
3153 
3154 TEST_P(UncheckedOptionalAccessTest, CtorInitializerNullopt) {
3155   using namespace ast_matchers;
3156   ExpectDiagnosticsFor(
3157       R"(
3158     #include "unchecked_optional_access_test.h"
3159 
3160     struct Target {
3161       Target(): opt($ns::nullopt) {
3162         opt.value(); // [[unsafe]]
3163       }
3164       $ns::$optional<int> opt;
3165     };
3166   )",
3167       cxxConstructorDecl(ofClass(hasName("Target"))));
3168 }
3169 
3170 TEST_P(UncheckedOptionalAccessTest, CtorInitializerValue) {
3171   using namespace ast_matchers;
3172   ExpectDiagnosticsFor(
3173       R"(
3174     #include "unchecked_optional_access_test.h"
3175 
3176     struct Target {
3177       Target(): opt(3) {
3178         opt.value();
3179       }
3180       $ns::$optional<int> opt;
3181     };
3182   )",
3183       cxxConstructorDecl(ofClass(hasName("Target"))));
3184 }
3185 
3186 // This is regression test, it shouldn't crash.
3187 TEST_P(UncheckedOptionalAccessTest, Bitfield) {
3188   using namespace ast_matchers;
3189   ExpectDiagnosticsFor(
3190       R"(
3191     #include "unchecked_optional_access_test.h"
3192     struct Dst {
3193       unsigned int n : 1;
3194     };
3195     void target() {
3196       $ns::$optional<bool> v;
3197       Dst d;
3198       if (v.has_value())
3199         d.n = v.value();
3200     }
3201   )");
3202 }
3203 // FIXME: Add support for:
3204 // - constructors (copy, move)
3205 // - assignment operators (default, copy, move)
3206 // - invalidation (passing optional by non-const reference/pointer)
3207