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