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