Utils: Remove variant.h

Since we are now requiring macOS 10.14 we can remove our local copy of
std::variant and use for macOS std::variant too.

Change-Id: I589d03b35fc56878b7392ffa7047a439e588fe43
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
Reviewed-by: Eike Ziller <eike.ziller@qt.io>

67 files changed, 414 insertions, 2958 deletions

diff --git a/src/libs/3rdparty/variant/LICENSE.md b/src/libs/3rdparty/variant/LICENSE.md
deleted file mode 100644
index 36b7cd93cd..0000000000
--- a/src/libs/3rdparty/variant/LICENSE.md
+++ /dev/null
@@ -1,23 +0,0 @@
-Boost Software License - Version 1.0 - August 17th, 2003
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
diff --git a/src/libs/3rdparty/variant/README.md b/src/libs/3rdparty/variant/README.md
deleted file mode 100644
index 6644286d27..0000000000
--- a/src/libs/3rdparty/variant/README.md
+++ /dev/null
@@ -1,37 +0,0 @@
-# MPark.Variant
-
-> __C++17__ `std::variant` for __C++11__/__14__/__17__
-
-[![release][badge.release]][release]
-[![header][badge.header]][header]
-[![travis][badge.travis]][travis]
-[![appveyor][badge.appveyor]][appveyor]
-[![license][badge.license]][license]
-[![godbolt][badge.godbolt]][godbolt]
-[![wandbox][badge.wandbox]][wandbox]
-
-[badge.release]: https://img.shields.io/github/release/mpark/variant.svg
-[badge.header]: https://img.shields.io/badge/single%20header-master-blue.svg
-[badge.travis]: https://travis-ci.org/mpark/variant.svg?branch=master
-[badge.appveyor]: https://ci.appveyor.com/api/projects/status/github/mpark/variant?branch=master&svg=true
-[badge.license]: https://img.shields.io/badge/license-boost-blue.svg
-[badge.godbolt]: https://img.shields.io/badge/try%20it-on%20godbolt-222266.svg
-[badge.wandbox]: https://img.shields.io/badge/try%20it-on%20wandbox-5cb85c.svg
-
-[release]: https://github.com/mpark/variant/releases/latest
-[header]: https://github.com/mpark/variant/blob/single-header/master/variant.hpp
-[travis]: https://travis-ci.org/mpark/variant
-[appveyor]: https://ci.appveyor.com/project/mpark/variant
-[license]: https://github.com/mpark/variant/blob/master/LICENSE.md
-[godbolt]: https://godbolt.org/g/1qYDAK
-[wandbox]: https://wandbox.org/permlink/QV3gZ2KQQNwgoFIB
-
-## Single Header
-
-This branch provides a standalone `variant.hpp` file for each
-[release](https://github.com/mpark/variant/releases).
-Copy it and `#include` away!
-
-## License
-
-Distributed under the [Boost Software License, Version 1.0](LICENSE.md).
diff --git a/src/libs/3rdparty/variant/variant.hpp b/src/libs/3rdparty/variant/variant.hpp
deleted file mode 100644
index dca26986c9..0000000000
--- a/src/libs/3rdparty/variant/variant.hpp
+++ /dev/null
@@ -1,2465 +0,0 @@
-// MPark.Variant
-//
-// Copyright Michael Park, 2015-2017
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
-
-#ifndef MPARK_VARIANT_HPP
-#define MPARK_VARIANT_HPP
-
-#if defined(__GNUC__) && __GNUC__ >= 9
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-copy"
-#endif
-
-/*
-   variant synopsis
-
-namespace std {
-
-  // 20.7.2, class template variant
-  template <class... Types>
-  class variant {
-  public:
-
-    // 20.7.2.1, constructors
-    constexpr variant() noexcept(see below);
-    variant(const variant&);
-    variant(variant&&) noexcept(see below);
-
-    template <class T> constexpr variant(T&&) noexcept(see below);
-
-    template <class T, class... Args>
-    constexpr explicit variant(in_place_type_t<T>, Args&&...);
-
-    template <class T, class U, class... Args>
-    constexpr explicit variant(
-        in_place_type_t<T>, initializer_list<U>, Args&&...);
-
-    template <size_t I, class... Args>
-    constexpr explicit variant(in_place_index_t<I>, Args&&...);
-
-    template <size_t I, class U, class... Args>
-    constexpr explicit variant(
-        in_place_index_t<I>, initializer_list<U>, Args&&...);
-
-    // 20.7.2.2, destructor
-    ~variant();
-
-    // 20.7.2.3, assignment
-    variant& operator=(const variant&);
-    variant& operator=(variant&&) noexcept(see below);
-
-    template <class T> variant& operator=(T&&) noexcept(see below);
-
-    // 20.7.2.4, modifiers
-    template <class T, class... Args>
-    T& emplace(Args&&...);
-
-    template <class T, class U, class... Args>
-    T& emplace(initializer_list<U>, Args&&...);
-
-    template <size_t I, class... Args>
-    variant_alternative<I, variant>& emplace(Args&&...);
-
-    template <size_t I, class U, class...  Args>
-    variant_alternative<I, variant>& emplace(initializer_list<U>, Args&&...);
-
-    // 20.7.2.5, value status
-    constexpr bool valueless_by_exception() const noexcept;
-    constexpr size_t index() const noexcept;
-
-    // 20.7.2.6, swap
-    void swap(variant&) noexcept(see below);
-  };
-
-  // 20.7.3, variant helper classes
-  template <class T> struct variant_size; // undefined
-
-  template <class T>
-  constexpr size_t variant_size_v = variant_size<T>::value;
-
-  template <class T> struct variant_size<const T>;
-  template <class T> struct variant_size<volatile T>;
-  template <class T> struct variant_size<const volatile T>;
-
-  template <class... Types>
-  struct variant_size<variant<Types...>>;
-
-  template <size_t I, class T> struct variant_alternative; // undefined
-
-  template <size_t I, class T>
-  using variant_alternative_t = typename variant_alternative<I, T>::type;
-
-  template <size_t I, class T> struct variant_alternative<I, const T>;
-  template <size_t I, class T> struct variant_alternative<I, volatile T>;
-  template <size_t I, class T> struct variant_alternative<I, const volatile T>;
-
-  template <size_t I, class... Types>
-  struct variant_alternative<I, variant<Types...>>;
-
-  constexpr size_t variant_npos = -1;
-
-  // 20.7.4, value access
-  template <class T, class... Types>
-  constexpr bool holds_alternative(const variant<Types...>&) noexcept;
-
-  template <size_t I, class... Types>
-  constexpr variant_alternative_t<I, variant<Types...>>&
-  get(variant<Types...>&);
-
-  template <size_t I, class... Types>
-  constexpr variant_alternative_t<I, variant<Types...>>&&
-  get(variant<Types...>&&);
-
-  template <size_t I, class... Types>
-  constexpr variant_alternative_t<I, variant<Types...>> const&
-  get(const variant<Types...>&);
-
-  template <size_t I, class... Types>
-  constexpr variant_alternative_t<I, variant<Types...>> const&&
-  get(const variant<Types...>&&);
-
-  template <class T, class...  Types>
-  constexpr T& get(variant<Types...>&);
-
-  template <class T, class... Types>
-  constexpr T&& get(variant<Types...>&&);
-
-  template <class T, class... Types>
-  constexpr const T& get(const variant<Types...>&);
-
-  template <class T, class... Types>
-  constexpr const T&& get(const variant<Types...>&&);
-
-  template <size_t I, class... Types>
-  constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>>
-  get_if(variant<Types...>*) noexcept;
-
-  template <size_t I, class... Types>
-  constexpr add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
-  get_if(const variant<Types...>*) noexcept;
-
-  template <class T, class... Types>
-  constexpr add_pointer_t<T>
-  get_if(variant<Types...>*) noexcept;
-
-  template <class T, class... Types>
-  constexpr add_pointer_t<const T>
-  get_if(const variant<Types...>*) noexcept;
-
-  // 20.7.5, relational operators
-  template <class... Types>
-  constexpr bool operator==(const variant<Types...>&, const variant<Types...>&);
-
-  template <class... Types>
-  constexpr bool operator!=(const variant<Types...>&, const variant<Types...>&);
-
-  template <class... Types>
-  constexpr bool operator<(const variant<Types...>&, const variant<Types...>&);
-
-  template <class... Types>
-  constexpr bool operator>(const variant<Types...>&, const variant<Types...>&);
-
-  template <class... Types>
-  constexpr bool operator<=(const variant<Types...>&, const variant<Types...>&);
-
-  template <class... Types>
-  constexpr bool operator>=(const variant<Types...>&, const variant<Types...>&);
-
-  // 20.7.6, visitation
-  template <class Visitor, class... Variants>
-  constexpr see below visit(Visitor&&, Variants&&...);
-
-  // 20.7.7, class monostate
-  struct monostate;
-
-  // 20.7.8, monostate relational operators
-  constexpr bool operator<(monostate, monostate) noexcept;
-  constexpr bool operator>(monostate, monostate) noexcept;
-  constexpr bool operator<=(monostate, monostate) noexcept;
-  constexpr bool operator>=(monostate, monostate) noexcept;
-  constexpr bool operator==(monostate, monostate) noexcept;
-  constexpr bool operator!=(monostate, monostate) noexcept;
-
-  // 20.7.9, specialized algorithms
-  template <class... Types>
-  void swap(variant<Types...>&, variant<Types...>&) noexcept(see below);
-
-  // 20.7.10, class bad_variant_access
-  class bad_variant_access;
-
-  // 20.7.11, hash support
-  template <class T> struct hash;
-  template <class... Types> struct hash<variant<Types...>>;
-  template <> struct hash<monostate>;
-
-} // namespace std
-
-*/
-
-#include <cstddef>
-#include <exception>
-#include <functional>
-#include <initializer_list>
-#include <new>
-#include <type_traits>
-#include <utility>
-
-// MPark.Variant
-//
-// Copyright Michael Park, 2015-2017
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
-
-#ifndef MPARK_CONFIG_HPP
-#define MPARK_CONFIG_HPP
-
-// MSVC 2015 Update 3.
-#if __cplusplus < 201103L && (!defined(_MSC_VER) || _MSC_FULL_VER < 190024210)
-#error "MPark.Variant requires C++11 support."
-#endif
-
-#ifndef __has_builtin
-#define __has_builtin(x) 0
-#endif
-
-#ifndef __has_include
-#define __has_include(x) 0
-#endif
-
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
-
-#if __has_builtin(__builtin_addressof) || \
-    (defined(__GNUC__) && __GNUC__ >= 7) || defined(_MSC_VER)
-#define MPARK_BUILTIN_ADDRESSOF
-#endif
-
-#if __has_builtin(__builtin_unreachable)
-#define MPARK_BUILTIN_UNREACHABLE
-#endif
-
-#if __has_builtin(__type_pack_element)
-#define MPARK_TYPE_PACK_ELEMENT
-#endif
-
-#if defined(__cpp_constexpr) && __cpp_constexpr >= 201304
-#if !defined(_MSC_VER) || _MSC_VER < 1915 // compile issue in msvc 2017 update 8
-#define MPARK_CPP14_CONSTEXPR
-#endif
-#endif
-
-#if __has_feature(cxx_exceptions) || defined(__cpp_exceptions) || \
-    (defined(_MSC_VER) && defined(_CPPUNWIND))
-#define MPARK_EXCEPTIONS
-#endif
-
-#if defined(__cpp_generic_lambdas) || defined(_MSC_VER)
-#define MPARK_GENERIC_LAMBDAS
-#endif
-
-#if defined(__cpp_lib_integer_sequence)
-#define MPARK_INTEGER_SEQUENCE
-#endif
-
-#if defined(__cpp_return_type_deduction) || defined(_MSC_VER)
-#define MPARK_RETURN_TYPE_DEDUCTION
-#endif
-
-#if defined(__cpp_lib_transparent_operators) || defined(_MSC_VER)
-#define MPARK_TRANSPARENT_OPERATORS
-#endif
-
-#if defined(__cpp_variable_templates) || defined(_MSC_VER)
-#define MPARK_VARIABLE_TEMPLATES
-#endif
-
-#if !defined(__GLIBCXX__) || __has_include(<codecvt>)  // >= libstdc++-5
-#define MPARK_TRIVIALITY_TYPE_TRAITS
-#endif
-
-#endif  // MPARK_CONFIG_HPP
-
-// MPark.Variant
-//
-// Copyright Michael Park, 2015-2017
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
-
-#ifndef MPARK_IN_PLACE_HPP
-#define MPARK_IN_PLACE_HPP
-
-#include <cstddef>
-
-
-namespace mpark {
-
-  struct in_place_t { explicit in_place_t() = default; };
-
-  template <std::size_t I>
-  struct in_place_index_t { explicit in_place_index_t() = default; };
-
-  template <typename T>
-  struct in_place_type_t { explicit in_place_type_t() = default; };
-
-#ifdef MPARK_VARIABLE_TEMPLATES
-  constexpr in_place_t in_place{};
-
-  template <std::size_t I> constexpr in_place_index_t<I> in_place_index{};
-
-  template <typename T> constexpr in_place_type_t<T> in_place_type{};
-#endif
-
-}  // namespace mpark
-
-#endif  // MPARK_IN_PLACE_HPP
-
-// MPark.Variant
-//
-// Copyright Michael Park, 2015-2017
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
-
-#ifndef MPARK_LIB_HPP
-#define MPARK_LIB_HPP
-
-#include <memory>
-#include <functional>
-#include <type_traits>
-#include <utility>
-
-
-#define RETURN(...)                                          \
-  noexcept(noexcept(__VA_ARGS__)) -> decltype(__VA_ARGS__) { \
-    return __VA_ARGS__;                                      \
-  }
-
-namespace mpark {
-  namespace lib {
-    template <typename T>
-    struct identity { using type = T; };
-
-    inline namespace cpp14 {
-      template <typename T, std::size_t N>
-      struct array {
-        constexpr const T &operator[](std::size_t index) const {
-          return data[index];
-        }
-
-        T data[N == 0 ? 1 : N];
-      };
-
-      template <typename T>
-      using add_pointer_t = typename std::add_pointer<T>::type;
-
-      template <typename... Ts>
-      using common_type_t = typename std::common_type<Ts...>::type;
-
-      template <typename T>
-      using decay_t = typename std::decay<T>::type;
-
-      template <bool B, typename T = void>
-      using enable_if_t = typename std::enable_if<B, T>::type;
-
-      template <typename T>
-      using remove_const_t = typename std::remove_const<T>::type;
-
-      template <typename T>
-      using remove_reference_t = typename std::remove_reference<T>::type;
-
-      template <typename T>
-      inline constexpr T &&forward(remove_reference_t<T> &t) noexcept {
-        return static_cast<T &&>(t);
-      }
-
-      template <typename T>
-      inline constexpr T &&forward(remove_reference_t<T> &&t) noexcept {
-        static_assert(!std::is_lvalue_reference<T>::value,
-                      "can not forward an rvalue as an lvalue");
-        return static_cast<T &&>(t);
-      }
-
-      template <typename T>
-      inline constexpr remove_reference_t<T> &&move(T &&t) noexcept {
-        return static_cast<remove_reference_t<T> &&>(t);
-      }
-
-#ifdef MPARK_INTEGER_SEQUENCE
-      using std::integer_sequence;
-      using std::index_sequence;
-      using std::make_index_sequence;
-      using std::index_sequence_for;
-#else
-      template <typename T, T... Is>
-      struct integer_sequence {
-        using value_type = T;
-        static constexpr std::size_t size() noexcept { return sizeof...(Is); }
-      };
-
-      template <std::size_t... Is>
-      using index_sequence = integer_sequence<std::size_t, Is...>;
-
-      template <typename Lhs, typename Rhs>
-      struct make_index_sequence_concat;
-
-      template <std::size_t... Lhs, std::size_t... Rhs>
-      struct make_index_sequence_concat<index_sequence<Lhs...>,
-                                        index_sequence<Rhs...>>
-          : identity<index_sequence<Lhs..., (sizeof...(Lhs) + Rhs)...>> {};
-
-      template <std::size_t N>
-      struct make_index_sequence_impl;
-
-      template <std::size_t N>
-      using make_index_sequence = typename make_index_sequence_impl<N>::type;
-
-      template <std::size_t N>
-      struct make_index_sequence_impl
-          : make_index_sequence_concat<make_index_sequence<N / 2>,
-                                       make_index_sequence<N - (N / 2)>> {};
-
-      template <>
-      struct make_index_sequence_impl<0> : identity<index_sequence<>> {};
-
-      template <>
-      struct make_index_sequence_impl<1> : identity<index_sequence<0>> {};
-
-      template <typename... Ts>
-      using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
-#endif
-
-      // <functional>
-#ifdef MPARK_TRANSPARENT_OPERATORS
-      using equal_to = std::equal_to<>;
-#else
-      struct equal_to {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          RETURN(lib::forward<Lhs>(lhs) == lib::forward<Rhs>(rhs))
-      };
-#endif
-
-#ifdef MPARK_TRANSPARENT_OPERATORS
-      using not_equal_to = std::not_equal_to<>;
-#else
-      struct not_equal_to {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          RETURN(lib::forward<Lhs>(lhs) != lib::forward<Rhs>(rhs))
-      };
-#endif
-
-#ifdef MPARK_TRANSPARENT_OPERATORS
-      using less = std::less<>;
-#else
-      struct less {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          RETURN(lib::forward<Lhs>(lhs) < lib::forward<Rhs>(rhs))
-      };
-#endif
-
-#ifdef MPARK_TRANSPARENT_OPERATORS
-      using greater = std::greater<>;
-#else
-      struct greater {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          RETURN(lib::forward<Lhs>(lhs) > lib::forward<Rhs>(rhs))
-      };
-#endif
-
-#ifdef MPARK_TRANSPARENT_OPERATORS
-      using less_equal = std::less_equal<>;
-#else
-      struct less_equal {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          RETURN(lib::forward<Lhs>(lhs) <= lib::forward<Rhs>(rhs))
-      };
-#endif
-
-#ifdef MPARK_TRANSPARENT_OPERATORS
-      using greater_equal = std::greater_equal<>;
-#else
-      struct greater_equal {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          RETURN(lib::forward<Lhs>(lhs) >= lib::forward<Rhs>(rhs))
-      };
-#endif
-    }  // namespace cpp14
-
-    inline namespace cpp17 {
-
-      // <type_traits>
-      template <bool B>
-      using bool_constant = std::integral_constant<bool, B>;
-
-      template <typename...>
-      struct voider : identity<void> {};
-
-      template <typename... Ts>
-      using void_t = typename voider<Ts...>::type;
-
-      namespace detail {
-        namespace swappable {
-
-          using std::swap;
-
-          template <typename T>
-          struct is_swappable {
-            private:
-            template <typename U,
-                      typename = decltype(swap(std::declval<U &>(),
-                                               std::declval<U &>()))>
-            inline static std::true_type test(int);
-
-            template <typename U>
-            inline static std::false_type test(...);
-
-            public:
-            static constexpr bool value = decltype(test<T>(0))::value;
-          };
-
-          template <typename T, bool = is_swappable<T>::value>
-          struct is_nothrow_swappable {
-            static constexpr bool value =
-                noexcept(swap(std::declval<T &>(), std::declval<T &>()));
-          };
-
-          template <typename T>
-          struct is_nothrow_swappable<T, false> : std::false_type {};
-
-        }  // namespace swappable
-      }  // namespace detail
-
-      using detail::swappable::is_swappable;
-      using detail::swappable::is_nothrow_swappable;
-
-      // <functional>
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4100)
-#endif
-      template <typename F, typename... As>
-      inline constexpr auto invoke(F &&f, As &&... as)
-          RETURN(lib::forward<F>(f)(lib::forward<As>(as)...))
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-      template <typename B, typename T, typename D>
-      inline constexpr auto invoke(T B::*pmv, D &&d)
-          RETURN(lib::forward<D>(d).*pmv)
-
-      template <typename Pmv, typename Ptr>
-      inline constexpr auto invoke(Pmv pmv, Ptr &&ptr)
-          RETURN((*lib::forward<Ptr>(ptr)).*pmv)
-
-      template <typename B, typename T, typename D, typename... As>
-      inline constexpr auto invoke(T B::*pmf, D &&d, As &&... as)
-          RETURN((lib::forward<D>(d).*pmf)(lib::forward<As>(as)...))
-
-      template <typename Pmf, typename Ptr, typename... As>
-      inline constexpr auto invoke(Pmf pmf, Ptr &&ptr, As &&... as)
-          RETURN(((*lib::forward<Ptr>(ptr)).*pmf)(lib::forward<As>(as)...))
-
-      namespace detail {
-
-        template <typename Void, typename, typename...>
-        struct invoke_result {};
-
-        template <typename F, typename... Args>
-        struct invoke_result<void_t<decltype(lib::invoke(
-                                 std::declval<F>(), std::declval<Args>()...))>,
-                             F,
-                             Args...>
-            : identity<decltype(
-                  lib::invoke(std::declval<F>(), std::declval<Args>()...))> {};
-
-      }  // namespace detail
-
-      template <typename F, typename... Args>
-      using invoke_result = detail::invoke_result<void, F, Args...>;
-
-      template <typename F, typename... Args>
-      using invoke_result_t = typename invoke_result<F, Args...>::type;
-
-      namespace detail {
-
-        template <typename Void, typename, typename...>
-        struct is_invocable : std::false_type {};
-
-        template <typename F, typename... Args>
-        struct is_invocable<void_t<invoke_result_t<F, Args...>>, F, Args...>
-            : std::true_type {};
-
-        template <typename Void, typename, typename, typename...>
-        struct is_invocable_r : std::false_type {};
-
-        template <typename R, typename F, typename... Args>
-        struct is_invocable_r<void_t<invoke_result_t<F, Args...>>,
-                              R,
-                              F,
-                              Args...>
-            : std::is_convertible<invoke_result_t<F, Args...>, R> {};
-
-      }  // namespace detail
-
-      template <typename F, typename... Args>
-      using is_invocable = detail::is_invocable<void, F, Args...>;
-
-      template <typename R, typename F, typename... Args>
-      using is_invocable_r = detail::is_invocable_r<void, R, F, Args...>;
-
-      // <memory>
-#ifdef MPARK_BUILTIN_ADDRESSOF
-      template <typename T>
-      inline constexpr T *addressof(T &arg) {
-        return __builtin_addressof(arg);
-      }
-#else
-      namespace detail {
-
-        namespace has_addressof_impl {
-
-          struct fail;
-
-          template <typename T>
-          inline fail operator&(T &&);
-
-          template <typename T>
-          inline static constexpr bool impl() {
-            return (std::is_class<T>::value || std::is_union<T>::value) &&
-                   !std::is_same<decltype(&std::declval<T &>()), fail>::value;
-          }
-
-        }  // namespace has_addressof_impl
-
-        template <typename T>
-        using has_addressof = bool_constant<has_addressof_impl::impl<T>()>;
-
-        template <typename T>
-        inline constexpr T *addressof(T &arg, std::true_type) {
-          return std::addressof(arg);
-        }
-
-        template <typename T>
-        inline constexpr T *addressof(T &arg, std::false_type) {
-          return &arg;
-        }
-
-      }  // namespace detail
-
-      template <typename T>
-      inline constexpr T *addressof(T &arg) {
-        return detail::addressof(arg, detail::has_addressof<T>{});
-      }
-#endif
-
-      template <typename T>
-      inline constexpr T *addressof(const T &&) = delete;
-
-    }  // namespace cpp17
-
-    template <typename T>
-    struct remove_all_extents : identity<T> {};
-
-    template <typename T, std::size_t N>
-    struct remove_all_extents<array<T, N>> : remove_all_extents<T> {};
-
-    template <typename T>
-    using remove_all_extents_t = typename remove_all_extents<T>::type;
-
-    template <std::size_t N>
-    using size_constant = std::integral_constant<std::size_t, N>;
-
-    template <std::size_t I, typename T>
-    struct indexed_type : size_constant<I>, identity<T> {};
-
-    template <bool... Bs>
-    using all = std::is_same<integer_sequence<bool, true, Bs...>,
-                             integer_sequence<bool, Bs..., true>>;
-
-#ifdef MPARK_TYPE_PACK_ELEMENT
-    template <std::size_t I, typename... Ts>
-    using type_pack_element_t = __type_pack_element<I, Ts...>;
-#else
-    template <std::size_t I, typename... Ts>
-    struct type_pack_element_impl {
-      private:
-      template <typename>
-      struct set;
-
-      template <std::size_t... Is>
-      struct set<index_sequence<Is...>> : indexed_type<Is, Ts>... {};
-
-      template <typename T>
-      inline static std::enable_if<true, T> impl(indexed_type<I, T>);
-
-      inline static std::enable_if<false> impl(...);
-
-      public:
-      using type = decltype(impl(set<index_sequence_for<Ts...>>{}));
-    };
-
-    template <std::size_t I, typename... Ts>
-    using type_pack_element = typename type_pack_element_impl<I, Ts...>::type;
-
-    template <std::size_t I, typename... Ts>
-    using type_pack_element_t = typename type_pack_element<I, Ts...>::type;
-#endif
-
-#ifdef MPARK_TRIVIALITY_TYPE_TRAITS
-    using std::is_trivially_copy_constructible;
-    using std::is_trivially_move_constructible;
-    using std::is_trivially_copy_assignable;
-    using std::is_trivially_move_assignable;
-#else
-    template <typename T>
-    struct is_trivially_copy_constructible
-        : bool_constant<
-              std::is_copy_constructible<T>::value && __has_trivial_copy(T)> {};
-
-    template <typename T>
-    struct is_trivially_move_constructible : bool_constant<__is_trivial(T)> {};
-
-    template <typename T>
-    struct is_trivially_copy_assignable
-        : bool_constant<
-              std::is_copy_assignable<T>::value && __has_trivial_assign(T)> {};
-
-    template <typename T>
-    struct is_trivially_move_assignable : bool_constant<__is_trivial(T)> {};
-#endif
-
-    template <typename T, bool>
-    struct dependent_type : T {};
-
-    template <typename Is, std::size_t J>
-    struct push_back;
-
-    template <typename Is, std::size_t J>
-    using push_back_t = typename push_back<Is, J>::type;
-
-    template <std::size_t... Is, std::size_t J>
-    struct push_back<index_sequence<Is...>, J> {
-      using type = index_sequence<Is..., J>;
-    };
-
-  }  // namespace lib
-}  // namespace mpark
-
-#undef RETURN
-
-#endif  // MPARK_LIB_HPP
-
-
-namespace mpark {
-
-#ifdef MPARK_RETURN_TYPE_DEDUCTION
-
-#define AUTO auto
-#define AUTO_RETURN(...) { return __VA_ARGS__; }
-
-#define AUTO_REFREF auto &&
-#define AUTO_REFREF_RETURN(...) { return __VA_ARGS__; }
-
-#define DECLTYPE_AUTO decltype(auto)
-#define DECLTYPE_AUTO_RETURN(...) { return __VA_ARGS__; }
-
-#else
-
-#define AUTO auto
-#define AUTO_RETURN(...) \
-  -> lib::decay_t<decltype(__VA_ARGS__)> { return __VA_ARGS__; }
-
-#define AUTO_REFREF auto
-#define AUTO_REFREF_RETURN(...)                                           \
-  -> decltype((__VA_ARGS__)) {                                            \
-    static_assert(std::is_reference<decltype((__VA_ARGS__))>::value, ""); \
-    return __VA_ARGS__;                                                   \
-  }
-
-#define DECLTYPE_AUTO auto
-#define DECLTYPE_AUTO_RETURN(...) \
-  -> decltype(__VA_ARGS__) { return __VA_ARGS__; }
-
-#endif
-
-  class bad_variant_access : public std::exception {
-    public:
-    virtual const char *what() const noexcept { return "bad_variant_access"; }
-  };
-
-  [[noreturn]] inline void throw_bad_variant_access() {
-#ifdef MPARK_EXCEPTIONS
-    throw bad_variant_access{};
-#else
-    std::terminate();
-#ifdef MPARK_BUILTIN_UNREACHABLE
-    __builtin_unreachable();
-#endif
-#endif
-  }
-
-  template <typename... Ts>
-  class variant;
-
-  template <typename T>
-  struct variant_size;
-
-#ifdef MPARK_VARIABLE_TEMPLATES
-  template <typename T>
-  constexpr std::size_t variant_size_v = variant_size<T>::value;
-#endif
-
-  template <typename T>
-  struct variant_size<const T> : variant_size<T> {};
-
-  template <typename T>
-  struct variant_size<volatile T> : variant_size<T> {};
-
-  template <typename T>
-  struct variant_size<const volatile T> : variant_size<T> {};
-
-  template <typename... Ts>
-  struct variant_size<variant<Ts...>> : lib::size_constant<sizeof...(Ts)> {};
-
-  template <std::size_t I, typename T>
-  struct variant_alternative;
-
-  template <std::size_t I, typename T>
-  using variant_alternative_t = typename variant_alternative<I, T>::type;
-
-  template <std::size_t I, typename T>
-  struct variant_alternative<I, const T>
-      : std::add_const<variant_alternative_t<I, T>> {};
-
-  template <std::size_t I, typename T>
-  struct variant_alternative<I, volatile T>
-      : std::add_volatile<variant_alternative_t<I, T>> {};
-
-  template <std::size_t I, typename T>
-  struct variant_alternative<I, const volatile T>
-      : std::add_cv<variant_alternative_t<I, T>> {};
-
-  template <std::size_t I, typename... Ts>
-  struct variant_alternative<I, variant<Ts...>> {
-    static_assert(I < sizeof...(Ts),
-                  "Index out of bounds in std::variant_alternative<>");
-    using type = lib::type_pack_element_t<I, Ts...>;
-  };
-
-  constexpr std::size_t variant_npos = static_cast<std::size_t>(-1);
-
-  namespace detail {
-
-    constexpr std::size_t not_found = static_cast<std::size_t>(-1);
-    constexpr std::size_t ambiguous = static_cast<std::size_t>(-2);
-
-#ifdef MPARK_CPP14_CONSTEXPR
-    template <typename T, typename... Ts>
-    inline constexpr std::size_t find_index() {
-      constexpr lib::array<bool, sizeof...(Ts)> matches = {
-          {std::is_same<T, Ts>::value...}
-      };
-      std::size_t result = not_found;
-      for (std::size_t i = 0; i < sizeof...(Ts); ++i) {
-        if (matches[i]) {
-          if (result != not_found) {
-            return ambiguous;
-          }
-          result = i;
-        }
-      }
-      return result;
-    }
-#else
-    inline constexpr std::size_t find_index_impl(std::size_t result,
-                                                 std::size_t) {
-      return result;
-    }
-
-    template <typename... Bs>
-    inline constexpr std::size_t find_index_impl(std::size_t result,
-                                                 std::size_t idx,
-                                                 bool b,
-                                                 Bs... bs) {
-      return b ? (result != not_found ? ambiguous
-                                      : find_index_impl(idx, idx + 1, bs...))
-               : find_index_impl(result, idx + 1, bs...);
-    }
-
-    template <typename T, typename... Ts>
-    inline constexpr std::size_t find_index() {
-      return find_index_impl(not_found, 0, std::is_same<T, Ts>::value...);
-    }
-#endif
-
-    template <std::size_t I>
-    using find_index_sfinae_impl =
-        lib::enable_if_t<I != not_found && I != ambiguous,
-                         lib::size_constant<I>>;
-
-    template <typename T, typename... Ts>
-    using find_index_sfinae = find_index_sfinae_impl<find_index<T, Ts...>()>;
-
-    template <std::size_t I>
-    struct find_index_checked_impl : lib::size_constant<I> {
-      static_assert(I != not_found, "the specified type is not found.");
-      static_assert(I != ambiguous, "the specified type is ambiguous.");
-    };
-
-    template <typename T, typename... Ts>
-    using find_index_checked = find_index_checked_impl<find_index<T, Ts...>()>;
-
-    struct valueless_t {};
-
-    enum class Trait { TriviallyAvailable, Available, Unavailable };
-
-    template <typename T,
-              template <typename> class IsTriviallyAvailable,
-              template <typename> class IsAvailable>
-    inline constexpr Trait trait() {
-      return IsTriviallyAvailable<T>::value
-                 ? Trait::TriviallyAvailable
-                 : IsAvailable<T>::value ? Trait::Available
-                                         : Trait::Unavailable;
-    }
-
-#ifdef MPARK_CPP14_CONSTEXPR
-    template <typename... Traits>
-    inline constexpr Trait common_trait(Traits... traits) {
-      Trait result = Trait::TriviallyAvailable;
-      for (Trait t : {traits...}) {
-        if (static_cast<int>(t) > static_cast<int>(result)) {
-          result = t;
-        }
-      }
-      return result;
-    }
-#else
-    inline constexpr Trait common_trait_impl(Trait result) { return result; }
-
-    template <typename... Traits>
-    inline constexpr Trait common_trait_impl(Trait result,
-                                             Trait t,
-                                             Traits... ts) {
-      return static_cast<int>(t) > static_cast<int>(result)
-                 ? common_trait_impl(t, ts...)
-                 : common_trait_impl(result, ts...);
-    }
-
-    template <typename... Traits>
-    inline constexpr Trait common_trait(Traits... ts) {
-      return common_trait_impl(Trait::TriviallyAvailable, ts...);
-    }
-#endif
-
-    template <typename... Ts>
-    struct traits {
-      static constexpr Trait copy_constructible_trait =
-          common_trait(trait<Ts,
-                             lib::is_trivially_copy_constructible,
-                             std::is_copy_constructible>()...);
-
-      static constexpr Trait move_constructible_trait =
-          common_trait(trait<Ts,
-                             lib::is_trivially_move_constructible,
-                             std::is_move_constructible>()...);
-
-      static constexpr Trait copy_assignable_trait =
-          common_trait(copy_constructible_trait,
-                       trait<Ts,
-                             lib::is_trivially_copy_assignable,
-                             std::is_copy_assignable>()...);
-
-      static constexpr Trait move_assignable_trait =
-          common_trait(move_constructible_trait,
-                       trait<Ts,
-                             lib::is_trivially_move_assignable,
-                             std::is_move_assignable>()...);
-
-      static constexpr Trait destructible_trait =
-          common_trait(trait<Ts,
-                             std::is_trivially_destructible,
-                             std::is_destructible>()...);
-    };
-
-    namespace access {
-
-      struct recursive_union {
-#ifdef MPARK_RETURN_TYPE_DEDUCTION
-        template <typename V>
-        inline static constexpr auto &&get_alt(V &&v, in_place_index_t<0>) {
-          return lib::forward<V>(v).head_;
-        }
-
-        template <typename V, std::size_t I>
-        inline static constexpr auto &&get_alt(V &&v, in_place_index_t<I>) {
-          return get_alt(lib::forward<V>(v).tail_, in_place_index_t<I - 1>{});
-        }
-#else
-        template <std::size_t I, bool Dummy = true>
-        struct get_alt_impl {
-          template <typename V>
-          inline constexpr AUTO_REFREF operator()(V &&v) const
-            AUTO_REFREF_RETURN(get_alt_impl<I - 1>{}(lib::forward<V>(v).tail_))
-        };
-
-        template <bool Dummy>
-        struct get_alt_impl<0, Dummy> {
-          template <typename V>
-          inline constexpr AUTO_REFREF operator()(V &&v) const
-            AUTO_REFREF_RETURN(lib::forward<V>(v).head_)
-        };
-
-        template <typename V, std::size_t I>
-        inline static constexpr AUTO_REFREF get_alt(V &&v, in_place_index_t<I>)
-          AUTO_REFREF_RETURN(get_alt_impl<I>{}(lib::forward<V>(v)))
-#endif
-      };
-
-      struct base {
-        template <std::size_t I, typename V>
-        inline static constexpr AUTO_REFREF get_alt(V &&v)
-          AUTO_REFREF_RETURN(recursive_union::get_alt(
-              data(lib::forward<V>(v)), in_place_index_t<I>{}))
-      };
-
-      struct variant {
-        template <std::size_t I, typename V>
-        inline static constexpr AUTO_REFREF get_alt(V &&v)
-          AUTO_REFREF_RETURN(base::get_alt<I>(lib::forward<V>(v).impl_))
-      };
-
-    }  // namespace access
-
-    namespace visitation {
-
-      struct base {
-        template <typename T>
-        inline static constexpr const T &at(const T &elem) {
-          return elem;
-        }
-
-        template <typename T, std::size_t N, typename... Is>
-        inline static constexpr const lib::remove_all_extents_t<T> &at(
-            const lib::array<T, N> &elems, std::size_t i, Is... is) {
-          return at(elems[i], is...);
-        }
-
-        template <typename F, typename... Fs>
-        inline static constexpr int visit_visitor_return_type_check() {
-          static_assert(lib::all<std::is_same<F, Fs>::value...>::value,
-                        "`mpark::visit` requires the visitor to have a single "
-                        "return type.");
-          return 0;
-        }
-
-        template <typename... Fs>
-        inline static constexpr lib::array<
-            lib::common_type_t<lib::decay_t<Fs>...>,
-            sizeof...(Fs)>
-        make_farray(Fs &&... fs) {
-          using result = lib::array<lib::common_type_t<lib::decay_t<Fs>...>,
-                                    sizeof...(Fs)>;
-          return visit_visitor_return_type_check<lib::decay_t<Fs>...>(),
-                 result{{lib::forward<Fs>(fs)...}};
-        }
-
-        template <std::size_t... Is>
-        struct dispatcher {
-          template <typename F, typename... Vs>
-          struct impl {
-            inline static constexpr DECLTYPE_AUTO dispatch(F f, Vs... vs)
-              DECLTYPE_AUTO_RETURN(lib::invoke(
-                  static_cast<F>(f),
-                  access::base::get_alt<Is>(static_cast<Vs>(vs))...))
-          };
-        };
-
-        template <typename F, typename... Vs, std::size_t... Is>
-        inline static constexpr AUTO make_dispatch(lib::index_sequence<Is...>)
-          AUTO_RETURN(&dispatcher<Is...>::template impl<F, Vs...>::dispatch)
-
-        template <std::size_t I, typename F, typename... Vs>
-        inline static constexpr AUTO make_fdiagonal_impl()
-          AUTO_RETURN(make_dispatch<F, Vs...>(
-              lib::index_sequence<lib::indexed_type<I, Vs>::value...>{}))
-
-        template <typename F, typename... Vs, std::size_t... Is>
-        inline static constexpr AUTO make_fdiagonal_impl(
-            lib::index_sequence<Is...>)
-          AUTO_RETURN(make_farray(make_fdiagonal_impl<Is, F, Vs...>()...))
-
-        template <typename F, typename V, typename... Vs>
-        inline static constexpr /* auto * */ auto make_fdiagonal()
-            -> decltype(make_fdiagonal_impl<F, V, Vs...>(
-                lib::make_index_sequence<lib::decay_t<V>::size()>{})) {
-          static_assert(lib::all<(lib::decay_t<V>::size() ==
-                                  lib::decay_t<Vs>::size())...>::value,
-                        "all of the variants must be the same size.");
-          return make_fdiagonal_impl<F, V, Vs...>(
-              lib::make_index_sequence<lib::decay_t<V>::size()>{});
-        }
-
-#ifdef MPARK_RETURN_TYPE_DEDUCTION
-        template <typename F, typename... Vs, typename Is>
-        inline static constexpr auto make_fmatrix_impl(Is is) {
-          return make_dispatch<F, Vs...>(is);
-        }
-
-        template <typename F,
-                  typename... Vs,
-                  typename Is,
-                  std::size_t... Js,
-                  typename... Ls>
-        inline static constexpr auto make_fmatrix_impl(
-            Is, lib::index_sequence<Js...>, Ls... ls) {
-          return make_farray(make_fmatrix_impl<F, Vs...>(
-              lib::push_back_t<Is, Js>{}, ls...)...);
-        }
-
-        template <typename F, typename... Vs>
-        inline static constexpr auto make_fmatrix() {
-          return make_fmatrix_impl<F, Vs...>(
-              lib::index_sequence<>{},
-              lib::make_index_sequence<lib::decay_t<Vs>::size()>{}...);
-        }
-#else
-        template <typename F, typename... Vs>
-        struct make_fmatrix_impl {
-          template <typename...>
-          struct impl;
-
-          template <typename Is>
-          struct impl<Is> {
-            inline constexpr AUTO operator()() const
-              AUTO_RETURN(make_dispatch<F, Vs...>(Is{}))
-          };
-
-          template <typename Is, std::size_t... Js, typename... Ls>
-          struct impl<Is, lib::index_sequence<Js...>, Ls...> {
-            inline constexpr AUTO operator()() const
-              AUTO_RETURN(
-                  make_farray(impl<lib::push_back_t<Is, Js>, Ls...>{}()...))
-          };
-        };
-
-        template <typename F, typename... Vs>
-        inline static constexpr AUTO make_fmatrix()
-          AUTO_RETURN(
-              typename make_fmatrix_impl<F, Vs...>::template impl<
-                  lib::index_sequence<>,
-                  lib::make_index_sequence<lib::decay_t<Vs>::size()>...>{}())
-#endif
-      };  // namespace base
-
-      template <typename F, typename... Vs>
-      using FDiagonal = decltype(base::make_fdiagonal<F, Vs...>());
-
-      template <typename F, typename... Vs>
-      struct fdiagonal {
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4268)
-#endif
-        static constexpr FDiagonal<F, Vs...> value =
-            base::make_fdiagonal<F, Vs...>();
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-      };
-
-      template <typename F, typename... Vs>
-      constexpr FDiagonal<F, Vs...> fdiagonal<F, Vs...>::value;
-
-      template <typename F, typename... Vs>
-      using FMatrix = decltype(base::make_fmatrix<F, Vs...>());
-
-      template <typename F, typename... Vs>
-      struct fmatrix {
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4268)
-#endif
-        static constexpr FMatrix<F, Vs...> value =
-            base::make_fmatrix<F, Vs...>();
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-      };
-
-      template <typename F, typename... Vs>
-      constexpr FMatrix<F, Vs...> fmatrix<F, Vs...>::value;
-
-      struct alt {
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_alt_at(std::size_t index,
-                                                           Visitor &&visitor,
-                                                           Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(base::at(
-              fdiagonal<Visitor &&,
-                        decltype(as_base(lib::forward<Vs>(vs)))...>::value,
-              index)(lib::forward<Visitor>(visitor),
-                     as_base(lib::forward<Vs>(vs))...))
-
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor,
-                                                        Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(base::at(
-              fmatrix<Visitor &&,
-                      decltype(as_base(lib::forward<Vs>(vs)))...>::value,
-              vs.index()...)(lib::forward<Visitor>(visitor),
-                             as_base(lib::forward<Vs>(vs))...))
-      };
-
-      struct variant {
-        private:
-        template <typename Visitor, typename... Values>
-        struct visit_exhaustive_visitor_check {
-          static_assert(
-              lib::is_invocable<Visitor, Values...>::value,
-              "`mpark::visit` requires the visitor to be exhaustive.");
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4100)
-#endif
-          inline constexpr DECLTYPE_AUTO operator()(Visitor &&visitor,
-                                                    Values &&... values) const
-            DECLTYPE_AUTO_RETURN(lib::invoke(lib::forward<Visitor>(visitor),
-                                             lib::forward<Values>(values)...))
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-        };
-
-        template <typename Visitor>
-        struct value_visitor {
-          Visitor &&visitor_;
-
-          template <typename... Alts>
-          inline constexpr DECLTYPE_AUTO operator()(Alts &&... alts) const
-            DECLTYPE_AUTO_RETURN(
-                visit_exhaustive_visitor_check<
-                    Visitor,
-                    decltype((lib::forward<Alts>(alts).value))...>{}(
-                    lib::forward<Visitor>(visitor_),
-                    lib::forward<Alts>(alts).value...))
-        };
-
-        template <typename Visitor>
-        inline static constexpr AUTO make_value_visitor(Visitor &&visitor)
-          AUTO_RETURN(value_visitor<Visitor>{lib::forward<Visitor>(visitor)})
-
-        public:
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_alt_at(std::size_t index,
-                                                           Visitor &&visitor,
-                                                           Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(
-              alt::visit_alt_at(index,
-                                lib::forward<Visitor>(visitor),
-                                lib::forward<Vs>(vs).impl_...))
-
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor,
-                                                        Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(alt::visit_alt(lib::forward<Visitor>(visitor),
-                                              lib::forward<Vs>(vs).impl_...))
-
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_value_at(std::size_t index,
-                                                             Visitor &&visitor,
-                                                             Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(
-              visit_alt_at(index,
-                           make_value_visitor(lib::forward<Visitor>(visitor)),
-                           lib::forward<Vs>(vs)...))
-
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_value(Visitor &&visitor,
-                                                          Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(
-              visit_alt(make_value_visitor(lib::forward<Visitor>(visitor)),
-                        lib::forward<Vs>(vs)...))
-      };
-
-    }  // namespace visitation
-
-    template <std::size_t Index, typename T>
-    struct alt {
-      using value_type = T;
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4244)
-#endif
-      template <typename... Args>
-      inline explicit constexpr alt(in_place_t, Args &&... args)
-          : value(lib::forward<Args>(args)...) {}
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-      T value;
-    };
-
-    template <Trait DestructibleTrait, std::size_t Index, typename... Ts>
-    union recursive_union;
-
-    template <Trait DestructibleTrait, std::size_t Index>
-    union recursive_union<DestructibleTrait, Index> {};
-
-#define MPARK_VARIANT_RECURSIVE_UNION(destructible_trait, destructor)      \
-  template <std::size_t Index, typename T, typename... Ts>                 \
-  union recursive_union<destructible_trait, Index, T, Ts...> {             \
-    public:                                                                \
-    inline explicit constexpr recursive_union(valueless_t) noexcept        \
-        : dummy_{} {}                                                      \
-                                                                           \
-    template <typename... Args>                                            \
-    inline explicit constexpr recursive_union(in_place_index_t<0>,         \
-                                              Args &&... args)             \
-        : head_(in_place_t{}, lib::forward<Args>(args)...) {}              \
-                                                                           \
-    template <std::size_t I, typename... Args>                             \
-    inline explicit constexpr recursive_union(in_place_index_t<I>,         \
-                                              Args &&... args)             \
-        : tail_(in_place_index_t<I - 1>{}, lib::forward<Args>(args)...) {} \
-                                                                           \
-    recursive_union(const recursive_union &) = default;                    \
-    recursive_union(recursive_union &&) = default;                         \
-                                                                           \
-    destructor                                                             \
-                                                                           \
-    recursive_union &operator=(const recursive_union &) = default;         \
-    recursive_union &operator=(recursive_union &&) = default;              \
-                                                                           \
-    private:                                                               \
-    char dummy_;                                                           \
-    alt<Index, T> head_;                                                   \
-    recursive_union<destructible_trait, Index + 1, Ts...> tail_;           \
-                                                                           \
-    friend struct access::recursive_union;                                 \
-  }
-
-    MPARK_VARIANT_RECURSIVE_UNION(Trait::TriviallyAvailable,
-                                  ~recursive_union() = default;);
-    MPARK_VARIANT_RECURSIVE_UNION(Trait::Available,
-                                  ~recursive_union() {});
-    MPARK_VARIANT_RECURSIVE_UNION(Trait::Unavailable,
-                                  ~recursive_union() = delete;);
-
-#undef MPARK_VARIANT_RECURSIVE_UNION
-
-    using index_t = unsigned int;
-
-    template <Trait DestructibleTrait, typename... Ts>
-    class base {
-      public:
-      inline explicit constexpr base(valueless_t tag) noexcept
-          : data_(tag), index_(static_cast<index_t>(-1)) {}
-
-      template <std::size_t I, typename... Args>
-      inline explicit constexpr base(in_place_index_t<I>, Args &&... args)
-          : data_(in_place_index_t<I>{}, lib::forward<Args>(args)...),
-            index_(I) {}
-
-      inline constexpr bool valueless_by_exception() const noexcept {
-        return index_ == static_cast<index_t>(-1);
-      }
-
-      inline constexpr std::size_t index() const noexcept {
-        return valueless_by_exception() ? variant_npos : index_;
-      }
-
-      protected:
-      using data_t = recursive_union<DestructibleTrait, 0, Ts...>;
-
-      friend inline constexpr base &as_base(base &b) { return b; }
-      friend inline constexpr const base &as_base(const base &b) { return b; }
-      friend inline constexpr base &&as_base(base &&b) { return lib::move(b); }
-      friend inline constexpr const base &&as_base(const base &&b) { return lib::move(b); }
-
-      friend inline constexpr data_t &data(base &b) { return b.data_; }
-      friend inline constexpr const data_t &data(const base &b) { return b.data_; }
-      friend inline constexpr data_t &&data(base &&b) { return lib::move(b).data_; }
-      friend inline constexpr const data_t &&data(const base &&b) { return lib::move(b).data_; }
-
-      inline static constexpr std::size_t size() { return sizeof...(Ts); }
-
-      data_t data_;
-      index_t index_;
-
-      friend struct access::base;
-      friend struct visitation::base;
-    };
-
-    struct dtor {
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4100)
-#endif
-      template <typename Alt>
-      inline void operator()(Alt &alt) const noexcept { alt.~Alt(); }
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-    };
-
-#if defined(_MSC_VER) && _MSC_VER < 1910
-#define INHERITING_CTOR(type, base)               \
-  template <typename... Args>                     \
-  inline explicit constexpr type(Args &&... args) \
-      : base(lib::forward<Args>(args)...) {}
-#else
-#define INHERITING_CTOR(type, base) using base::base;
-#endif
-
-    template <typename Traits, Trait = Traits::destructible_trait>
-    class destructor;
-
-#define MPARK_VARIANT_DESTRUCTOR(destructible_trait, definition, destroy) \
-  template <typename... Ts>                                               \
-  class destructor<traits<Ts...>, destructible_trait>                     \
-      : public base<destructible_trait, Ts...> {                          \
-    using super = base<destructible_trait, Ts...>;                        \
-                                                                          \
-    public:                                                               \
-    INHERITING_CTOR(destructor, super)                                    \
-    using super::operator=;                                               \
-                                                                          \
-    destructor(const destructor &) = default;                             \
-    destructor(destructor &&) = default;                                  \
-    definition                                                            \
-    destructor &operator=(const destructor &) = default;                  \
-    destructor &operator=(destructor &&) = default;                       \
-                                                                          \
-    protected:                                                            \
-    destroy                                                               \
-  }
-
-    MPARK_VARIANT_DESTRUCTOR(
-        Trait::TriviallyAvailable,
-        ~destructor() = default;,
-        inline void destroy() noexcept {
-          this->index_ = static_cast<index_t>(-1);
-        });
-
-    MPARK_VARIANT_DESTRUCTOR(
-        Trait::Available,
-        ~destructor() { destroy(); },
-        inline void destroy() noexcept {
-          if (!this->valueless_by_exception()) {
-            visitation::alt::visit_alt(dtor{}, *this);
-          }
-          this->index_ = static_cast<index_t>(-1);
-        });
-
-    MPARK_VARIANT_DESTRUCTOR(
-        Trait::Unavailable,
-        ~destructor() = delete;,
-        inline void destroy() noexcept = delete;);
-
-#undef MPARK_VARIANT_DESTRUCTOR
-
-    template <typename Traits>
-    class constructor : public destructor<Traits> {
-      using super = destructor<Traits>;
-
-      public:
-      INHERITING_CTOR(constructor, super)
-      using super::operator=;
-
-      protected:
-#ifndef MPARK_GENERIC_LAMBDAS
-      struct ctor {
-        template <typename LhsAlt, typename RhsAlt>
-        inline void operator()(LhsAlt &lhs_alt, RhsAlt &&rhs_alt) const {
-          constructor::construct_alt(lhs_alt,
-                                     lib::forward<RhsAlt>(rhs_alt).value);
-        }
-      };
-#endif
-
-      template <std::size_t I, typename T, typename... Args>
-      inline static T &construct_alt(alt<I, T> &a, Args &&... args) {
-        ::new (static_cast<void *>(lib::addressof(a)))
-            alt<I, T>(in_place_t{}, lib::forward<Args>(args)...);
-        return a.value;
-      }
-
-      template <typename Rhs>
-      inline static void generic_construct(constructor &lhs, Rhs &&rhs) {
-        lhs.destroy();
-        if (!rhs.valueless_by_exception()) {
-          visitation::alt::visit_alt_at(
-              rhs.index(),
-#ifdef MPARK_GENERIC_LAMBDAS
-              [](auto &lhs_alt, auto &&rhs_alt) {
-                constructor::construct_alt(
-                    lhs_alt, lib::forward<decltype(rhs_alt)>(rhs_alt).value);
-              }
-#else
-              ctor{}
-#endif
-              ,
-              lhs,
-              lib::forward<Rhs>(rhs));
-          lhs.index_ = rhs.index_;
-        }
-      }
-    };
-
-    template <typename Traits, Trait = Traits::move_constructible_trait>
-    class move_constructor;
-
-#define MPARK_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait, definition) \
-  template <typename... Ts>                                                  \
-  class move_constructor<traits<Ts...>, move_constructible_trait>            \
-      : public constructor<traits<Ts...>> {                                  \
-    using super = constructor<traits<Ts...>>;                                \
-                                                                             \
-    public:                                                                  \
-    INHERITING_CTOR(move_constructor, super)                                 \
-    using super::operator=;                                                  \
-                                                                             \
-    move_constructor(const move_constructor &) = default;                    \
-    definition                                                               \
-    ~move_constructor() = default;                                           \
-    move_constructor &operator=(const move_constructor &) = default;         \
-    move_constructor &operator=(move_constructor &&) = default;              \
-  }
-
-    MPARK_VARIANT_MOVE_CONSTRUCTOR(
-        Trait::TriviallyAvailable,
-        move_constructor(move_constructor &&that) = default;);
-
-    MPARK_VARIANT_MOVE_CONSTRUCTOR(
-        Trait::Available,
-        move_constructor(move_constructor &&that) noexcept(
-            lib::all<std::is_nothrow_move_constructible<Ts>::value...>::value)
-            : move_constructor(valueless_t{}) {
-          this->generic_construct(*this, lib::move(that));
-        });
-
-    MPARK_VARIANT_MOVE_CONSTRUCTOR(
-        Trait::Unavailable,
-        move_constructor(move_constructor &&) = delete;);
-
-#undef MPARK_VARIANT_MOVE_CONSTRUCTOR
-
-    template <typename Traits, Trait = Traits::copy_constructible_trait>
-    class copy_constructor;
-
-#define MPARK_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, definition) \
-  template <typename... Ts>                                                  \
-  class copy_constructor<traits<Ts...>, copy_constructible_trait>            \
-      : public move_constructor<traits<Ts...>> {                             \
-    using super = move_constructor<traits<Ts...>>;                           \
-                                                                             \
-    public:                                                                  \
-    INHERITING_CTOR(copy_constructor, super)                                 \
-    using super::operator=;                                                  \
-                                                                             \
-    definition                                                               \
-    copy_constructor(copy_constructor &&) = default;                         \
-    ~copy_constructor() = default;                                           \
-    copy_constructor &operator=(const copy_constructor &) = default;         \
-    copy_constructor &operator=(copy_constructor &&) = default;              \
-  }
-
-    MPARK_VARIANT_COPY_CONSTRUCTOR(
-        Trait::TriviallyAvailable,
-        copy_constructor(const copy_constructor &that) = default;);
-
-    MPARK_VARIANT_COPY_CONSTRUCTOR(
-        Trait::Available,
-        copy_constructor(const copy_constructor &that)
-            : copy_constructor(valueless_t{}) {
-          this->generic_construct(*this, that);
-        });
-
-    MPARK_VARIANT_COPY_CONSTRUCTOR(
-        Trait::Unavailable,
-        copy_constructor(const copy_constructor &) = delete;);
-
-#undef MPARK_VARIANT_COPY_CONSTRUCTOR
-
-    template <typename Traits>
-    class assignment : public copy_constructor<Traits> {
-      using super = copy_constructor<Traits>;
-
-      public:
-      INHERITING_CTOR(assignment, super)
-      using super::operator=;
-
-      template <std::size_t I, typename... Args>
-      inline /* auto & */ auto emplace(Args &&... args)
-          -> decltype(this->construct_alt(access::base::get_alt<I>(*this),
-                                          lib::forward<Args>(args)...)) {
-        this->destroy();
-        auto &result = this->construct_alt(access::base::get_alt<I>(*this),
-                                           lib::forward<Args>(args)...);
-        this->index_ = I;
-        return result;
-      }
-
-      protected:
-#ifndef MPARK_GENERIC_LAMBDAS
-      template <typename That>
-      struct assigner {
-        template <typename ThisAlt, typename ThatAlt>
-        inline void operator()(ThisAlt &this_alt, ThatAlt &&that_alt) const {
-          self->assign_alt(this_alt, lib::forward<ThatAlt>(that_alt).value);
-        }
-        assignment *self;
-      };
-#endif
-
-      template <std::size_t I, typename T, typename Arg>
-      inline void assign_alt(alt<I, T> &a, Arg &&arg) {
-        if (this->index() == I) {
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4244)
-#endif
-          a.value = lib::forward<Arg>(arg);
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-        } else {
-          struct {
-            void operator()(std::true_type) const {
-              this_->emplace<I>(lib::forward<Arg>(arg_));
-            }
-            void operator()(std::false_type) const {
-              this_->emplace<I>(T(lib::forward<Arg>(arg_)));
-            }
-            assignment *this_;
-            Arg &&arg_;
-          } impl{this, lib::forward<Arg>(arg)};
-          impl(lib::bool_constant<
-                   std::is_nothrow_constructible<T, Arg>::value ||
-                   !std::is_nothrow_move_constructible<T>::value>{});
-        }
-      }
-
-      template <typename That>
-      inline void generic_assign(That &&that) {
-        if (this->valueless_by_exception() && that.valueless_by_exception()) {
-          // do nothing.
-        } else if (that.valueless_by_exception()) {
-          this->destroy();
-        } else {
-          visitation::alt::visit_alt_at(
-              that.index(),
-#ifdef MPARK_GENERIC_LAMBDAS
-              [this](auto &this_alt, auto &&that_alt) {
-                this->assign_alt(
-                    this_alt, lib::forward<decltype(that_alt)>(that_alt).value);
-              }
-#else
-              assigner<That>{this}
-#endif
-              ,
-              *this,
-              lib::forward<That>(that));
-        }
-      }
-    };
-
-    template <typename Traits, Trait = Traits::move_assignable_trait>
-    class move_assignment;
-
-#define MPARK_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, definition) \
-  template <typename... Ts>                                              \
-  class move_assignment<traits<Ts...>, move_assignable_trait>            \
-      : public assignment<traits<Ts...>> {                               \
-    using super = assignment<traits<Ts...>>;                             \
-                                                                         \
-    public:                                                              \
-    INHERITING_CTOR(move_assignment, super)                              \
-    using super::operator=;                                              \
-                                                                         \
-    move_assignment(const move_assignment &) = default;                  \
-    move_assignment(move_assignment &&) = default;                       \
-    ~move_assignment() = default;                                        \
-    move_assignment &operator=(const move_assignment &) = default;       \
-    definition                                                           \
-  }
-
-    MPARK_VARIANT_MOVE_ASSIGNMENT(
-        Trait::TriviallyAvailable,
-        move_assignment &operator=(move_assignment &&that) = default;);
-
-    MPARK_VARIANT_MOVE_ASSIGNMENT(
-        Trait::Available,
-        move_assignment &
-        operator=(move_assignment &&that) noexcept(
-            lib::all<(std::is_nothrow_move_constructible<Ts>::value &&
-                      std::is_nothrow_move_assignable<Ts>::value)...>::value) {
-          this->generic_assign(lib::move(that));
-          return *this;
-        });
-
-    MPARK_VARIANT_MOVE_ASSIGNMENT(
-        Trait::Unavailable,
-        move_assignment &operator=(move_assignment &&) = delete;);
-
-#undef MPARK_VARIANT_MOVE_ASSIGNMENT
-
-    template <typename Traits, Trait = Traits::copy_assignable_trait>
-    class copy_assignment;
-
-#define MPARK_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, definition) \
-  template <typename... Ts>                                              \
-  class copy_assignment<traits<Ts...>, copy_assignable_trait>            \
-      : public move_assignment<traits<Ts...>> {                          \
-    using super = move_assignment<traits<Ts...>>;                        \
-                                                                         \
-    public:                                                              \
-    INHERITING_CTOR(copy_assignment, super)                              \
-    using super::operator=;                                              \
-                                                                         \
-    copy_assignment(const copy_assignment &) = default;                  \
-    copy_assignment(copy_assignment &&) = default;                       \
-    ~copy_assignment() = default;                                        \
-    definition                                                           \
-    copy_assignment &operator=(copy_assignment &&) = default;            \
-  }
-
-    MPARK_VARIANT_COPY_ASSIGNMENT(
-        Trait::TriviallyAvailable,
-        copy_assignment &operator=(const copy_assignment &that) = default;);
-
-    MPARK_VARIANT_COPY_ASSIGNMENT(
-        Trait::Available,
-        copy_assignment &operator=(const copy_assignment &that) {
-          this->generic_assign(that);
-          return *this;
-        });
-
-    MPARK_VARIANT_COPY_ASSIGNMENT(
-        Trait::Unavailable,
-        copy_assignment &operator=(const copy_assignment &) = delete;);
-
-#undef MPARK_VARIANT_COPY_ASSIGNMENT
-
-    template <typename... Ts>
-    class impl : public copy_assignment<traits<Ts...>> {
-      using super = copy_assignment<traits<Ts...>>;
-
-      public:
-      INHERITING_CTOR(impl, super)
-      using super::operator=;
-
-      template <std::size_t I, typename Arg>
-      inline void assign(Arg &&arg) {
-        this->assign_alt(access::base::get_alt<I>(*this),
-                         lib::forward<Arg>(arg));
-      }
-
-      inline void swap(impl &that) {
-        if (this->valueless_by_exception() && that.valueless_by_exception()) {
-          // do nothing.
-        } else if (this->index() == that.index()) {
-          visitation::alt::visit_alt_at(this->index(),
-#ifdef MPARK_GENERIC_LAMBDAS
-                                        [](auto &this_alt, auto &that_alt) {
-                                          using std::swap;
-                                          swap(this_alt.value,
-                                               that_alt.value);
-                                        }
-#else
-                                        swapper{}
-#endif
-                                        ,
-                                        *this,
-                                        that);
-        } else {
-          impl *lhs = this;
-          impl *rhs = lib::addressof(that);
-          if (lhs->move_nothrow() && !rhs->move_nothrow()) {
-            std::swap(lhs, rhs);
-          }
-          impl tmp(lib::move(*rhs));
-#ifdef MPARK_EXCEPTIONS
-          // EXTENSION: When the move construction of `lhs` into `rhs` throws
-          // and `tmp` is nothrow move constructible then we move `tmp` back
-          // into `rhs` and provide the strong exception safety guarantee.
-          try {
-            this->generic_construct(*rhs, lib::move(*lhs));
-          } catch (...) {
-            if (tmp.move_nothrow()) {
-              this->generic_construct(*rhs, lib::move(tmp));
-            }
-            throw;
-          }
-#else
-          this->generic_construct(*rhs, lib::move(*lhs));
-#endif
-          this->generic_construct(*lhs, lib::move(tmp));
-        }
-      }
-
-      private:
-#ifndef MPARK_GENERIC_LAMBDAS
-      struct swapper {
-        template <typename ThisAlt, typename ThatAlt>
-        inline void operator()(ThisAlt &this_alt, ThatAlt &that_alt) const {
-          using std::swap;
-          swap(this_alt.value, that_alt.value);
-        }
-      };
-#endif
-
-      inline constexpr bool move_nothrow() const {
-        return this->valueless_by_exception() ||
-               lib::array<bool, sizeof...(Ts)>{
-                   {std::is_nothrow_move_constructible<Ts>::value...}
-               }[this->index()];
-      }
-    };
-
-    template <std::size_t I, typename T>
-    struct overload_leaf {
-      using F = lib::size_constant<I> (*)(T);
-      operator F() const { return nullptr; }
-    };
-
-    template <typename... Ts>
-    struct overload_impl {
-      private:
-      template <typename>
-      struct impl;
-
-      template <std::size_t... Is>
-      struct impl<lib::index_sequence<Is...>> : overload_leaf<Is, Ts>... {};
-
-      public:
-      using type = impl<lib::index_sequence_for<Ts...>>;
-    };
-
-    template <typename... Ts>
-    using overload = typename overload_impl<Ts...>::type;
-
-    template <typename T, typename... Ts>
-    using best_match = lib::invoke_result_t<overload<Ts...>, T &&>;
-
-    template <typename T>
-    struct is_in_place_index : std::false_type {};
-
-    template <std::size_t I>
-    struct is_in_place_index<in_place_index_t<I>> : std::true_type {};
-
-    template <typename T>
-    struct is_in_place_type : std::false_type {};
-
-    template <typename T>
-    struct is_in_place_type<in_place_type_t<T>> : std::true_type {};
-
-  }  // detail
-
-  template <typename... Ts>
-  class variant {
-    static_assert(0 < sizeof...(Ts),
-                  "variant must consist of at least one alternative.");
-
-    static_assert(lib::all<!std::is_array<Ts>::value...>::value,
-                  "variant can not have an array type as an alternative.");
-
-    static_assert(lib::all<!std::is_reference<Ts>::value...>::value,
-                  "variant can not have a reference type as an alternative.");
-
-    static_assert(lib::all<!std::is_void<Ts>::value...>::value,
-                  "variant can not have a void type as an alternative.");
-
-    public:
-    template <
-        typename Front = lib::type_pack_element_t<0, Ts...>,
-        lib::enable_if_t<std::is_default_constructible<Front>::value, int> = 0>
-    inline constexpr variant()
-        : impl_(in_place_index_t<0>{}) {}
-
-    variant(const variant &) = default;
-    variant(variant &&) = default;
-
-    template <
-        typename Arg,
-        typename Decayed = lib::decay_t<Arg>,
-        lib::enable_if_t<!std::is_same<Decayed, variant>::value, int> = 0,
-        lib::enable_if_t<!detail::is_in_place_index<Decayed>::value, int> = 0,
-        lib::enable_if_t<!detail::is_in_place_type<Decayed>::value, int> = 0,
-        std::size_t I = detail::best_match<Arg, Ts...>::value,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T, Arg>::value, int> = 0>
-    inline constexpr variant(Arg &&arg) noexcept(
-        std::is_nothrow_constructible<T, Arg>::value)
-        : impl_(in_place_index_t<I>{}, lib::forward<Arg>(arg)) {}
-
-    template <
-        std::size_t I,
-        typename... Args,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline explicit constexpr variant(
-        in_place_index_t<I>,
-        Args &&... args) noexcept(std::is_nothrow_constructible<T,
-                                                                Args...>::value)
-        : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...) {}
-
-    template <
-        std::size_t I,
-        typename Up,
-        typename... Args,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T,
-                                               std::initializer_list<Up> &,
-                                               Args...>::value,
-                         int> = 0>
-    inline explicit constexpr variant(
-        in_place_index_t<I>,
-        std::initializer_list<Up> il,
-        Args &&... args) noexcept(std::
-                                      is_nothrow_constructible<
-                                          T,
-                                          std::initializer_list<Up> &,
-                                          Args...>::value)
-        : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...) {}
-
-    template <
-        typename T,
-        typename... Args,
-        std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
-        lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline explicit constexpr variant(
-        in_place_type_t<T>,
-        Args &&... args) noexcept(std::is_nothrow_constructible<T,
-                                                                Args...>::value)
-        : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...) {}
-
-    template <
-        typename T,
-        typename Up,
-        typename... Args,
-        std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
-        lib::enable_if_t<std::is_constructible<T,
-                                               std::initializer_list<Up> &,
-                                               Args...>::value,
-                         int> = 0>
-    inline explicit constexpr variant(
-        in_place_type_t<T>,
-        std::initializer_list<Up> il,
-        Args &&... args) noexcept(std::
-                                      is_nothrow_constructible<
-                                          T,
-                                          std::initializer_list<Up> &,
-                                          Args...>::value)
-        : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...) {}
-
-    ~variant() = default;
-
-    variant &operator=(const variant &) = default;
-    variant &operator=(variant &&) = default;
-
-    template <typename Arg,
-              lib::enable_if_t<!std::is_same<lib::decay_t<Arg>, variant>::value,
-                               int> = 0,
-              std::size_t I = detail::best_match<Arg, Ts...>::value,
-              typename T = lib::type_pack_element_t<I, Ts...>,
-              lib::enable_if_t<(std::is_assignable<T &, Arg>::value &&
-                                std::is_constructible<T, Arg>::value),
-                               int> = 0>
-    inline variant &operator=(Arg &&arg) {
-      impl_.template assign<I>(lib::forward<Arg>(arg));
-      return *this;
-    }
-
-    template <
-        std::size_t I,
-        typename... Args,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline T &emplace(Args &&... args) {
-      return impl_.template emplace<I>(lib::forward<Args>(args)...);
-    }
-
-    template <
-        std::size_t I,
-        typename Up,
-        typename... Args,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T,
-                                               std::initializer_list<Up> &,
-                                               Args...>::value,
-                         int> = 0>
-    inline T &emplace(std::initializer_list<Up> il, Args &&... args) {
-      return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
-    }
-
-    template <
-        typename T,
-        typename... Args,
-        std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
-        lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline T &emplace(Args &&... args) {
-      return impl_.template emplace<I>(lib::forward<Args>(args)...);
-    }
-
-    template <
-        typename T,
-        typename Up,
-        typename... Args,
-        std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
-        lib::enable_if_t<std::is_constructible<T,
-                                               std::initializer_list<Up> &,
-                                               Args...>::value,
-                         int> = 0>
-    inline T &emplace(std::initializer_list<Up> il, Args &&... args) {
-      return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
-    }
-
-    inline constexpr bool valueless_by_exception() const noexcept {
-      return impl_.valueless_by_exception();
-    }
-
-    inline constexpr std::size_t index() const noexcept {
-      return impl_.index();
-    }
-
-    template <bool Dummy = true,
-              lib::enable_if_t<
-                  lib::all<Dummy,
-                           (lib::dependent_type<std::is_move_constructible<Ts>,
-                                                Dummy>::value &&
-                            lib::dependent_type<lib::is_swappable<Ts>,
-                                                Dummy>::value)...>::value,
-                  int> = 0>
-    inline void swap(variant &that) noexcept(
-        lib::all<(std::is_nothrow_move_constructible<Ts>::value &&
-                  lib::is_nothrow_swappable<Ts>::value)...>::value) {
-      impl_.swap(that.impl_);
-    }
-
-    private:
-    detail::impl<Ts...> impl_;
-
-    friend struct detail::access::variant;
-    friend struct detail::visitation::variant;
-  };
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr bool holds_alternative(const variant<Ts...> &v) noexcept {
-    return v.index() == I;
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr bool holds_alternative(const variant<Ts...> &v) noexcept {
-    return holds_alternative<detail::find_index_checked<T, Ts...>::value>(v);
-  }
-
-  namespace detail {
-    template <std::size_t I, typename V>
-    struct generic_get_impl {
-      constexpr generic_get_impl(int) {}
-
-      constexpr AUTO_REFREF operator()(V &&v) const
-        AUTO_REFREF_RETURN(
-            access::variant::get_alt<I>(lib::forward<V>(v)).value)
-    };
-
-    template <std::size_t I, typename V>
-    inline constexpr AUTO_REFREF generic_get(V &&v)
-      AUTO_REFREF_RETURN(generic_get_impl<I, V>(
-          holds_alternative<I>(v) ? 0 : (throw_bad_variant_access(), 0))(
-          lib::forward<V>(v)))
-  }  // namespace detail
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr variant_alternative_t<I, variant<Ts...>> &get(
-      variant<Ts...> &v) {
-    return detail::generic_get<I>(v);
-  }
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr variant_alternative_t<I, variant<Ts...>> &&get(
-      variant<Ts...> &&v) {
-    return detail::generic_get<I>(lib::move(v));
-  }
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr const variant_alternative_t<I, variant<Ts...>> &get(
-      const variant<Ts...> &v) {
-    return detail::generic_get<I>(v);
-  }
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr const variant_alternative_t<I, variant<Ts...>> &&get(
-      const variant<Ts...> &&v) {
-    return detail::generic_get<I>(lib::move(v));
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr T &get(variant<Ts...> &v) {
-    return get<detail::find_index_checked<T, Ts...>::value>(v);
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr T &&get(variant<Ts...> &&v) {
-    return get<detail::find_index_checked<T, Ts...>::value>(lib::move(v));
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr const T &get(const variant<Ts...> &v) {
-    return get<detail::find_index_checked<T, Ts...>::value>(v);
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr const T &&get(const variant<Ts...> &&v) {
-    return get<detail::find_index_checked<T, Ts...>::value>(lib::move(v));
-  }
-
-  namespace detail {
-
-    template <std::size_t I, typename V>
-    inline constexpr /* auto * */ AUTO generic_get_if(V *v) noexcept
-      AUTO_RETURN(v && holds_alternative<I>(*v)
-                      ? lib::addressof(access::variant::get_alt<I>(*v).value)
-                      : nullptr)
-
-  }  // namespace detail
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr lib::add_pointer_t<variant_alternative_t<I, variant<Ts...>>>
-  get_if(variant<Ts...> *v) noexcept {
-    return detail::generic_get_if<I>(v);
-  }
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr lib::add_pointer_t<
-      const variant_alternative_t<I, variant<Ts...>>>
-  get_if(const variant<Ts...> *v) noexcept {
-    return detail::generic_get_if<I>(v);
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr lib::add_pointer_t<T>
-  get_if(variant<Ts...> *v) noexcept {
-    return get_if<detail::find_index_checked<T, Ts...>::value>(v);
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr lib::add_pointer_t<const T>
-  get_if(const variant<Ts...> *v) noexcept {
-    return get_if<detail::find_index_checked<T, Ts...>::value>(v);
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator==(const variant<Ts...> &lhs,
-                                   const variant<Ts...> &rhs) {
-    using detail::visitation::variant;
-    using lib::equal_to;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (lhs.index() != rhs.index()) return false;
-    if (lhs.valueless_by_exception()) return true;
-    return variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs);
-#else
-    return lhs.index() == rhs.index() &&
-           (lhs.valueless_by_exception() ||
-            variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs));
-#endif
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator!=(const variant<Ts...> &lhs,
-                                   const variant<Ts...> &rhs) {
-    using detail::visitation::variant;
-    using lib::not_equal_to;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (lhs.index() != rhs.index()) return true;
-    if (lhs.valueless_by_exception()) return false;
-    return variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs);
-#else
-    return lhs.index() != rhs.index() ||
-           (!lhs.valueless_by_exception() &&
-            variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs));
-#endif
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator<(const variant<Ts...> &lhs,
-                                  const variant<Ts...> &rhs) {
-    using detail::visitation::variant;
-    using lib::less;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (rhs.valueless_by_exception()) return false;
-    if (lhs.valueless_by_exception()) return true;
-    if (lhs.index() < rhs.index()) return true;
-    if (lhs.index() > rhs.index()) return false;
-    return variant::visit_value_at(lhs.index(), less{}, lhs, rhs);
-#else
-    return !rhs.valueless_by_exception() &&
-           (lhs.valueless_by_exception() || lhs.index() < rhs.index() ||
-            (lhs.index() == rhs.index() &&
-             variant::visit_value_at(lhs.index(), less{}, lhs, rhs)));
-#endif
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator>(const variant<Ts...> &lhs,
-                                  const variant<Ts...> &rhs) {
-    using detail::visitation::variant;
-    using lib::greater;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (lhs.valueless_by_exception()) return false;
-    if (rhs.valueless_by_exception()) return true;
-    if (lhs.index() > rhs.index()) return true;
-    if (lhs.index() < rhs.index()) return false;
-    return variant::visit_value_at(lhs.index(), greater{}, lhs, rhs);
-#else
-    return !lhs.valueless_by_exception() &&
-           (rhs.valueless_by_exception() || lhs.index() > rhs.index() ||
-            (lhs.index() == rhs.index() &&
-             variant::visit_value_at(lhs.index(), greater{}, lhs, rhs)));
-#endif
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator<=(const variant<Ts...> &lhs,
-                                   const variant<Ts...> &rhs) {
-    using detail::visitation::variant;
-    using lib::less_equal;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (lhs.valueless_by_exception()) return true;
-    if (rhs.valueless_by_exception()) return false;
-    if (lhs.index() < rhs.index()) return true;
-    if (lhs.index() > rhs.index()) return false;
-    return variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs);
-#else
-    return lhs.valueless_by_exception() ||
-           (!rhs.valueless_by_exception() &&
-            (lhs.index() < rhs.index() ||
-             (lhs.index() == rhs.index() &&
-              variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs))));
-#endif
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator>=(const variant<Ts...> &lhs,
-                                   const variant<Ts...> &rhs) {
-    using detail::visitation::variant;
-    using lib::greater_equal;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (rhs.valueless_by_exception()) return true;
-    if (lhs.valueless_by_exception()) return false;
-    if (lhs.index() > rhs.index()) return true;
-    if (lhs.index() < rhs.index()) return false;
-    return variant::visit_value_at(lhs.index(), greater_equal{}, lhs, rhs);
-#else
-    return rhs.valueless_by_exception() ||
-           (!lhs.valueless_by_exception() &&
-            (lhs.index() > rhs.index() ||
-             (lhs.index() == rhs.index() &&
-              variant::visit_value_at(
-                  lhs.index(), greater_equal{}, lhs, rhs))));
-#endif
-  }
-
-  struct monostate {};
-
-  inline constexpr bool operator<(monostate, monostate) noexcept {
-    return false;
-  }
-
-  inline constexpr bool operator>(monostate, monostate) noexcept {
-    return false;
-  }
-
-  inline constexpr bool operator<=(monostate, monostate) noexcept {
-    return true;
-  }
-
-  inline constexpr bool operator>=(monostate, monostate) noexcept {
-    return true;
-  }
-
-  inline constexpr bool operator==(monostate, monostate) noexcept {
-    return true;
-  }
-
-  inline constexpr bool operator!=(monostate, monostate) noexcept {
-    return false;
-  }
-
-#ifdef MPARK_CPP14_CONSTEXPR
-  namespace detail {
-
-    inline constexpr bool all(std::initializer_list<bool> bs) {
-      for (bool b : bs) {
-        if (!b) {
-          return false;
-        }
-      }
-      return true;
-    }
-
-  }  // namespace detail
-
-  template <typename Visitor, typename... Vs>
-  inline constexpr decltype(auto) visit(Visitor &&visitor, Vs &&... vs) {
-    return (detail::all({!vs.valueless_by_exception()...})
-                ? (void)0
-                : throw_bad_variant_access()),
-           detail::visitation::variant::visit_value(
-               lib::forward<Visitor>(visitor), lib::forward<Vs>(vs)...);
-  }
-#else
-  namespace detail {
-
-    template <std::size_t N>
-    inline constexpr bool all_impl(const lib::array<bool, N> &bs,
-                                   std::size_t idx) {
-      return idx >= N || (bs[idx] && all_impl(bs, idx + 1));
-    }
-
-    template <std::size_t N>
-    inline constexpr bool all(const lib::array<bool, N> &bs) {
-      return all_impl(bs, 0);
-    }
-
-  }  // namespace detail
-
-  template <typename Visitor, typename... Vs>
-  inline constexpr DECLTYPE_AUTO visit(Visitor &&visitor, Vs &&... vs)
-    DECLTYPE_AUTO_RETURN(
-        (detail::all(
-             lib::array<bool, sizeof...(Vs)>{{!vs.valueless_by_exception()...}})
-             ? (void)0
-             : throw_bad_variant_access()),
-        detail::visitation::variant::visit_value(lib::forward<Visitor>(visitor),
-                                                 lib::forward<Vs>(vs)...))
-#endif
-
-  template <typename... Ts>
-  inline auto swap(variant<Ts...> &lhs,
-                   variant<Ts...> &rhs) noexcept(noexcept(lhs.swap(rhs)))
-      -> decltype(lhs.swap(rhs)) {
-    lhs.swap(rhs);
-  }
-
-  namespace detail {
-
-    template <typename T, typename...>
-    using enabled_type = T;
-
-    namespace hash {
-
-      template <typename H, typename K>
-      constexpr bool meets_requirements() {
-        return std::is_copy_constructible<H>::value &&
-               std::is_move_constructible<H>::value &&
-               lib::is_invocable_r<std::size_t, H, const K &>::value;
-      }
-
-      template <typename K>
-      constexpr bool is_enabled() {
-        using H = std::hash<K>;
-        return meets_requirements<H, K>() &&
-               std::is_default_constructible<H>::value &&
-               std::is_copy_assignable<H>::value &&
-               std::is_move_assignable<H>::value;
-      }
-
-    }  // namespace hash
-
-  }  // namespace detail
-
-#undef AUTO
-#undef AUTO_RETURN
-
-#undef AUTO_REFREF
-#undef AUTO_REFREF_RETURN
-
-#undef DECLTYPE_AUTO
-#undef DECLTYPE_AUTO_RETURN
-
-}  // namespace mpark
-
-namespace std {
-
-  template <typename... Ts>
-  struct hash<mpark::detail::enabled_type<
-      mpark::variant<Ts...>,
-      mpark::lib::enable_if_t<mpark::lib::all<mpark::detail::hash::is_enabled<
-          mpark::lib::remove_const_t<Ts>>()...>::value>>> {
-    using argument_type = mpark::variant<Ts...>;
-    using result_type = std::size_t;
-
-    inline result_type operator()(const argument_type &v) const {
-      using mpark::detail::visitation::variant;
-      std::size_t result =
-          v.valueless_by_exception()
-              ? 299792458  // Random value chosen by the universe upon creation
-              : variant::visit_alt(
-#ifdef MPARK_GENERIC_LAMBDAS
-                    [](const auto &alt) {
-                      using alt_type = mpark::lib::decay_t<decltype(alt)>;
-                      using value_type = mpark::lib::remove_const_t<
-                          typename alt_type::value_type>;
-                      return hash<value_type>{}(alt.value);
-                    }
-#else
-                    hasher{}
-#endif
-                    ,
-                    v);
-      return hash_combine(result, hash<std::size_t>{}(v.index()));
-    }
-
-    private:
-#ifndef MPARK_GENERIC_LAMBDAS
-    struct hasher {
-      template <typename Alt>
-      inline std::size_t operator()(const Alt &alt) const {
-        using alt_type = mpark::lib::decay_t<Alt>;
-        using value_type =
-            mpark::lib::remove_const_t<typename alt_type::value_type>;
-        return hash<value_type>{}(alt.value);
-      }
-    };
-#endif
-
-    static std::size_t hash_combine(std::size_t lhs, std::size_t rhs) {
-      return lhs ^= rhs + 0x9e3779b9 + (lhs << 6) + (lhs >> 2);
-    }
-  };
-
-  template <>
-  struct hash<mpark::monostate> {
-    using argument_type = mpark::monostate;
-    using result_type = std::size_t;
-
-    inline result_type operator()(const argument_type &) const noexcept {
-      return 66740831;  // return a fundamentally attractive random value.
-    }
-  };
-
-}  // namespace std
-
-#if defined(__GNUC__) && __GNUC__ >= 9
-#pragma GCC diagnostic pop
-#endif
-
-#endif  // MPARK_VARIANT_HPP
diff --git a/src/libs/languageserverprotocol/clientcapabilities.cpp b/src/libs/languageserverprotocol/clientcapabilities.cpp
index 33c29df928..ce4e5ca073 100644
--- a/src/libs/languageserverprotocol/clientcapabilities.cpp
+++ b/src/libs/languageserverprotocol/clientcapabilities.cpp
@@ -47,10 +47,10 @@ WorkspaceClientCapabilities::WorkspaceClientCapabilities()
     setWorkspaceFolders(true);
 }
 
-Utils::optional<Utils::variant<bool, QJsonObject>> SemanticTokensClientCapabilities::Requests::range()
+Utils::optional<std::variant<bool, QJsonObject>> SemanticTokensClientCapabilities::Requests::range()
     const
 {
-    using RetType = Utils::variant<bool, QJsonObject>;
+    using RetType = std::variant<bool, QJsonObject>;
     const QJsonValue &rangeOptions = value(rangeKey);
     if (rangeOptions.isBool())
         return RetType(rangeOptions.toBool());
@@ -60,15 +60,15 @@ Utils::optional<Utils::variant<bool, QJsonObject>> SemanticTokensClientCapabilit
 }
 
 void SemanticTokensClientCapabilities::Requests::setRange(
-    const Utils::variant<bool, QJsonObject> &range)
+    const std::variant<bool, QJsonObject> &range)
 {
     insertVariant<bool, QJsonObject>(rangeKey, range);
 }
 
-Utils::optional<Utils::variant<bool, FullSemanticTokenOptions>>
+Utils::optional<std::variant<bool, FullSemanticTokenOptions>>
 SemanticTokensClientCapabilities::Requests::full() const
 {
-    using RetType = Utils::variant<bool, FullSemanticTokenOptions>;
+    using RetType = std::variant<bool, FullSemanticTokenOptions>;
     const QJsonValue &fullOptions = value(fullKey);
     if (fullOptions.isBool())
         return RetType(fullOptions.toBool());
@@ -78,7 +78,7 @@ SemanticTokensClientCapabilities::Requests::full() const
 }
 
 void SemanticTokensClientCapabilities::Requests::setFull(
-    const Utils::variant<bool, FullSemanticTokenOptions> &full)
+    const std::variant<bool, FullSemanticTokenOptions> &full)
 {
     insertVariant<bool, FullSemanticTokenOptions>(fullKey, full);
 }
diff --git a/src/libs/languageserverprotocol/clientcapabilities.h b/src/libs/languageserverprotocol/clientcapabilities.h
index 93a7181de7..7af0d12a93 100644
--- a/src/libs/languageserverprotocol/clientcapabilities.h
+++ b/src/libs/languageserverprotocol/clientcapabilities.h
@@ -78,16 +78,16 @@ public:
          * The client will send the `textDocument/semanticTokens/range` request
          * if the server provides a corresponding handler.
          */
-        Utils::optional<Utils::variant<bool, QJsonObject>> range() const;
-        void setRange(const Utils::variant<bool, QJsonObject> &range);
+        Utils::optional<std::variant<bool, QJsonObject>> range() const;
+        void setRange(const std::variant<bool, QJsonObject> &range);
         void clearRange() { remove(rangeKey); }
 
         /**
          * The client will send the `textDocument/semanticTokens/full` request
          * if the server provides a corresponding handler.
          */
-        Utils::optional<Utils::variant<bool, FullSemanticTokenOptions>> full() const;
-        void setFull(const Utils::variant<bool, FullSemanticTokenOptions> &full);
+        Utils::optional<std::variant<bool, FullSemanticTokenOptions>> full() const;
+        void setFull(const std::variant<bool, FullSemanticTokenOptions> &full);
         void clearFull() { remove(fullKey); }
     };
 
diff --git a/src/libs/languageserverprotocol/completion.h b/src/libs/languageserverprotocol/completion.h
index 1aa1f2ff53..d3630ad123 100644
--- a/src/libs/languageserverprotocol/completion.h
+++ b/src/libs/languageserverprotocol/completion.h
@@ -263,7 +263,7 @@ public:
 
 /// The result of a completion is CompletionItem[] | CompletionList | null
 class LANGUAGESERVERPROTOCOL_EXPORT CompletionResult
-        : public Utils::variant<QList<CompletionItem>, CompletionList, std::nullptr_t>
+        : public std::variant<QList<CompletionItem>, CompletionList, std::nullptr_t>
 {
 public:
     using variant::variant;
diff --git a/src/libs/languageserverprotocol/jsonobject.h b/src/libs/languageserverprotocol/jsonobject.h
index 9dd172bbef..fea9309483 100644
--- a/src/libs/languageserverprotocol/jsonobject.h
+++ b/src/libs/languageserverprotocol/jsonobject.h
@@ -112,7 +112,7 @@ private:
 template<typename T, typename V>
 JsonObject::iterator JsonObject::insertVariant(const QStringView key, const V &variant)
 {
-    return Utils::holds_alternative<T>(variant) ? insert(key, Utils::get<T>(variant)) : end();
+    return std::holds_alternative<T>(variant) ? insert(key, std::get<T>(variant)) : end();
 }
 
 template<typename T1, typename T2, typename... Args, typename V>
diff --git a/src/libs/languageserverprotocol/jsonrpcmessages.h b/src/libs/languageserverprotocol/jsonrpcmessages.h
index 3764775eae..4e37e38db8 100644
--- a/src/libs/languageserverprotocol/jsonrpcmessages.h
+++ b/src/libs/languageserverprotocol/jsonrpcmessages.h
@@ -31,7 +31,6 @@
 
 #include <utils/optional.h>
 #include <utils/qtcassert.h>
-#include <utils/variant.h>
 
 #include <QDebug>
 #include <QElapsedTimer>
@@ -41,11 +40,13 @@
 #include <QCoreApplication>
 #include <QUuid>
 
+#include <variant>
+
 namespace LanguageServerProtocol {
 
 class JsonRpcMessage;
 
-class LANGUAGESERVERPROTOCOL_EXPORT MessageId : public Utils::variant<int, QString>
+class LANGUAGESERVERPROTOCOL_EXPORT MessageId : public std::variant<int, QString>
 {
 public:
     MessageId() : variant(QString()) {}
@@ -61,37 +62,37 @@ public:
 
     operator QJsonValue() const
     {
-        if (auto id = Utils::get_if<int>(this))
+        if (auto id = std::get_if<int>(this))
             return *id;
-        if (auto id = Utils::get_if<QString>(this))
+        if (auto id = std::get_if<QString>(this))
             return *id;
         return QJsonValue();
     }
 
     bool isValid() const
     {
-        if (Utils::holds_alternative<int>(*this))
+        if (std::holds_alternative<int>(*this))
             return true;
-        const QString *id = Utils::get_if<QString>(this);
+        const QString *id = std::get_if<QString>(this);
         QTC_ASSERT(id, return false);
         return !id->isEmpty();
     }
 
     QString toString() const
     {
-        if (auto id = Utils::get_if<QString>(this))
+        if (auto id = std::get_if<QString>(this))
             return *id;
-        if (auto id = Utils::get_if<int>(this))
+        if (auto id = std::get_if<int>(this))
             return QString::number(*id);
         return {};
     }
 
     friend auto qHash(const MessageId &id)
     {
-        if (Utils::holds_alternative<int>(id))
-            return QT_PREPEND_NAMESPACE(qHash(Utils::get<int>(id)));
-        if (Utils::holds_alternative<QString>(id))
-            return QT_PREPEND_NAMESPACE(qHash(Utils::get<QString>(id)));
+        if (std::holds_alternative<int>(id))
+            return QT_PREPEND_NAMESPACE(qHash(std::get<int>(id)));
+        if (std::holds_alternative<QString>(id))
+            return QT_PREPEND_NAMESPACE(qHash(std::get<QString>(id)));
         return QT_PREPEND_NAMESPACE(qHash(0));
     }
 };
@@ -99,10 +100,10 @@ public:
 template <typename Error>
 inline QDebug operator<<(QDebug stream, const LanguageServerProtocol::MessageId &id)
 {
-    if (Utils::holds_alternative<int>(id))
-        stream << Utils::get<int>(id);
+    if (std::holds_alternative<int>(id))
+        stream << std::get<int>(id);
     else
-        stream << Utils::get<QString>(id);
+        stream << std::get<QString>(id);
     return stream;
 }
 
diff --git a/src/libs/languageserverprotocol/languagefeatures.cpp b/src/libs/languageserverprotocol/languagefeatures.cpp
index 367f22799d..630bba6d5d 100644
--- a/src/libs/languageserverprotocol/languagefeatures.cpp
+++ b/src/libs/languageserverprotocol/languagefeatures.cpp
@@ -57,11 +57,11 @@ HoverContent LanguageServerProtocol::Hover::content() const
 
 void Hover::setContent(const HoverContent &content)
 {
-    if (auto val = Utils::get_if<MarkedString>(&content))
+    if (auto val = std::get_if<MarkedString>(&content))
         insert(contentsKey, *val);
-    else if (auto val = Utils::get_if<MarkupContent>(&content))
+    else if (auto val = std::get_if<MarkupContent>(&content))
         insert(contentsKey, *val);
-    else if (auto val = Utils::get_if<QList<MarkedString>>(&content))
+    else if (auto val = std::get_if<QList<MarkedString>>(&content))
         insert(contentsKey, LanguageClientArray<MarkedString>(*val).toJson());
     else
         QTC_ASSERT_STRING("LanguageClient Using unknown type Hover::setContent");
@@ -160,7 +160,7 @@ QHash<QString, DocumentFormattingProperty> FormattingOptions::properties() const
 
 void FormattingOptions::setProperty(const QString &key, const DocumentFormattingProperty &property)
 {
-    using namespace Utils;
+    using namespace std;
     if (auto val = get_if<double>(&property))
         insert(key, *val);
     else if (auto val = get_if<QString>(&property))
@@ -293,16 +293,16 @@ MarkedString::MarkedString(const QJsonValue &value)
 
 bool MarkedString::isValid() const
 {
-    if (auto markedLanguageString = Utils::get_if<MarkedLanguageString>(this))
+    if (auto markedLanguageString = std::get_if<MarkedLanguageString>(this))
         return markedLanguageString->isValid();
     return true;
 }
 
 LanguageServerProtocol::MarkedString::operator QJsonValue() const
 {
-    if (auto val = Utils::get_if<QString>(this))
+    if (auto val = std::get_if<QString>(this))
         return *val;
-    if (auto val = Utils::get_if<MarkedLanguageString>(this))
+    if (auto val = std::get_if<MarkedLanguageString>(this))
         return QJsonValue(*val);
     return {};
 }
@@ -325,8 +325,8 @@ HoverContent::HoverContent(const QJsonValue &value)
 
 bool HoverContent::isValid() const
 {
-    if (Utils::holds_alternative<MarkedString>(*this))
-        return Utils::get<MarkedString>(*this).isValid();
+    if (std::holds_alternative<MarkedString>(*this))
+        return std::get<MarkedString>(*this).isValid();
     return true;
 }
 
@@ -346,7 +346,7 @@ SignatureHelpRequest::SignatureHelpRequest(const TextDocumentPositionParams &par
 
 CodeActionResult::CodeActionResult(const QJsonValue &val)
 {
-    using ResultArray = QList<Utils::variant<Command, CodeAction>>;
+    using ResultArray = QList<std::variant<Command, CodeAction>>;
     if (val.isArray()) {
         const QJsonArray array = val.toArray();
         ResultArray result;
@@ -368,21 +368,21 @@ CodeActionResult::CodeActionResult(const QJsonValue &val)
 }
 
 PrepareRenameResult::PrepareRenameResult()
-    : Utils::variant<PlaceHolderResult, Range, std::nullptr_t>(nullptr)
+    : std::variant<PlaceHolderResult, Range, std::nullptr_t>(nullptr)
 {}
 
 PrepareRenameResult::PrepareRenameResult(
-    const Utils::variant<PlaceHolderResult, Range, std::nullptr_t> &val)
-    : Utils::variant<PlaceHolderResult, Range, std::nullptr_t>(val)
+    const std::variant<PlaceHolderResult, Range, std::nullptr_t> &val)
+    : std::variant<PlaceHolderResult, Range, std::nullptr_t>(val)
 {}
 
 PrepareRenameResult::PrepareRenameResult(const PlaceHolderResult &val)
-    : Utils::variant<PlaceHolderResult, Range, std::nullptr_t>(val)
+    : std::variant<PlaceHolderResult, Range, std::nullptr_t>(val)
 
 {}
 
 PrepareRenameResult::PrepareRenameResult(const Range &val)
-    : Utils::variant<PlaceHolderResult, Range, std::nullptr_t>(val)
+    : std::variant<PlaceHolderResult, Range, std::nullptr_t>(val)
 {}
 
 PrepareRenameResult::PrepareRenameResult(const QJsonValue &val)
@@ -413,7 +413,7 @@ HoverResult::HoverResult(const QJsonValue &value)
 
 bool HoverResult::isValid() const
 {
-    if (auto hover = Utils::get_if<Hover>(this))
+    if (auto hover = std::get_if<Hover>(this))
         return hover->isValid();
     return true;
 }
diff --git a/src/libs/languageserverprotocol/languagefeatures.h b/src/libs/languageserverprotocol/languagefeatures.h
index 36979692ab..e3b16a9cb5 100644
--- a/src/libs/languageserverprotocol/languagefeatures.h
+++ b/src/libs/languageserverprotocol/languagefeatures.h
@@ -58,7 +58,7 @@ public:
 };
 
 class LANGUAGESERVERPROTOCOL_EXPORT MarkedString
-    : public Utils::variant<QString, MarkedLanguageString>
+    : public std::variant<QString, MarkedLanguageString>
 {
 public:
     MarkedString() = default;
@@ -75,7 +75,7 @@ public:
 };
 
 class LANGUAGESERVERPROTOCOL_EXPORT HoverContent
-    : public Utils::variant<MarkedString, QList<MarkedString>, MarkupContent>
+    : public std::variant<MarkedString, QList<MarkedString>, MarkupContent>
 {
 public:
     HoverContent() = default;
@@ -101,7 +101,7 @@ public:
     bool isValid() const override { return contains(contentsKey); }
 };
 
-class LANGUAGESERVERPROTOCOL_EXPORT HoverResult : public Utils::variant<Hover, std::nullptr_t>
+class LANGUAGESERVERPROTOCOL_EXPORT HoverResult : public std::variant<Hover, std::nullptr_t>
 {
 public:
     HoverResult() : variant(nullptr) {}
@@ -216,7 +216,7 @@ public:
 
 /// The result of a goto request can either be a location, a list of locations or null
 class LANGUAGESERVERPROTOCOL_EXPORT GotoResult
-        : public Utils::variant<Location, QList<Location>, std::nullptr_t>
+        : public std::variant<Location, QList<Location>, std::nullptr_t>
 {
 public:
     explicit GotoResult(const QJsonValue &value);
@@ -307,7 +307,7 @@ public:
 };
 
 class LANGUAGESERVERPROTOCOL_EXPORT DocumentHighlightsResult
-        : public Utils::variant<QList<DocumentHighlight>, std::nullptr_t>
+        : public std::variant<QList<DocumentHighlight>, std::nullptr_t>
 {
 public:
     using variant::variant;
@@ -343,7 +343,7 @@ public:
 using DocumentSymbolParams = TextDocumentParams;
 
 class LANGUAGESERVERPROTOCOL_EXPORT DocumentSymbolsResult
-        : public Utils::variant<QList<SymbolInformation>, QList<DocumentSymbol>, std::nullptr_t>
+        : public std::variant<QList<SymbolInformation>, QList<DocumentSymbol>, std::nullptr_t>
 {
 public:
     using variant::variant;
@@ -468,7 +468,7 @@ public:
 };
 
 class LANGUAGESERVERPROTOCOL_EXPORT CodeActionResult
-    : public Utils::variant<QList<Utils::variant<Command, CodeAction>>, std::nullptr_t>
+    : public std::variant<QList<std::variant<Command, CodeAction>>, std::nullptr_t>
 {
 public:
     using variant::variant;
@@ -658,13 +658,13 @@ public:
     constexpr static const char methodName[] = "textDocument/colorPresentation";
 };
 
-class DocumentFormattingProperty : public Utils::variant<bool, double, QString>
+class DocumentFormattingProperty : public std::variant<bool, double, QString>
 {
 public:
     DocumentFormattingProperty() = default;
     explicit DocumentFormattingProperty(const QJsonValue &value);
     explicit DocumentFormattingProperty(const DocumentFormattingProperty &other)
-        : Utils::variant<bool, double, QString>(other) {}
+        : std::variant<bool, double, QString>(other) {}
 
     using variant::variant;
     using variant::operator=;
@@ -806,11 +806,11 @@ public:
 };
 
 class LANGUAGESERVERPROTOCOL_EXPORT PrepareRenameResult
-    : public Utils::variant<PlaceHolderResult, Range, std::nullptr_t>
+    : public std::variant<PlaceHolderResult, Range, std::nullptr_t>
 {
 public:
     PrepareRenameResult();
-    PrepareRenameResult(const Utils::variant<PlaceHolderResult, Range, std::nullptr_t> &val);
+    PrepareRenameResult(const std::variant<PlaceHolderResult, Range, std::nullptr_t> &val);
     explicit PrepareRenameResult(const PlaceHolderResult &val);
     explicit PrepareRenameResult(const Range &val);
     explicit PrepareRenameResult(const QJsonValue &val);
diff --git a/src/libs/languageserverprotocol/lsptypes.cpp b/src/libs/languageserverprotocol/lsptypes.cpp
index 196f4f4375..3afb0f22e7 100644
--- a/src/libs/languageserverprotocol/lsptypes.cpp
+++ b/src/libs/languageserverprotocol/lsptypes.cpp
@@ -95,16 +95,16 @@ WorkSpaceFolder::WorkSpaceFolder(const DocumentUri &uri, const QString &name)
     setName(name);
 }
 
-MarkupOrString::MarkupOrString(const Utils::variant<QString, MarkupContent> &val)
-    : Utils::variant<QString, MarkupContent>(val)
+MarkupOrString::MarkupOrString(const std::variant<QString, MarkupContent> &val)
+    : std::variant<QString, MarkupContent>(val)
 { }
 
 MarkupOrString::MarkupOrString(const QString &val)
-    : Utils::variant<QString, MarkupContent>(val)
+    : std::variant<QString, MarkupContent>(val)
 { }
 
 MarkupOrString::MarkupOrString(const MarkupContent &val)
-    : Utils::variant<QString, MarkupContent>(val)
+    : std::variant<QString, MarkupContent>(val)
 { }
 
 MarkupOrString::MarkupOrString(const QJsonValue &val)
@@ -120,10 +120,10 @@ MarkupOrString::MarkupOrString(const QJsonValue &val)
 
 QJsonValue MarkupOrString::toJson() const
 {
-    if (Utils::holds_alternative<QString>(*this))
-        return Utils::get<QString>(*this);
-    if (Utils::holds_alternative<MarkupContent>(*this))
-        return QJsonValue(Utils::get<MarkupContent>(*this));
+    if (std::holds_alternative<QString>(*this))
+        return std::get<QString>(*this);
+    if (std::holds_alternative<MarkupContent>(*this))
+        return QJsonValue(std::get<MarkupContent>(*this));
     return {};
 }
 
diff --git a/src/libs/languageserverprotocol/lsptypes.h b/src/libs/languageserverprotocol/lsptypes.h
index e151e4afa0..ebb37d1563 100644
--- a/src/libs/languageserverprotocol/lsptypes.h
+++ b/src/libs/languageserverprotocol/lsptypes.h
@@ -34,7 +34,6 @@
 #include <utils/mimeutils.h>
 #include <utils/optional.h>
 #include <utils/textutils.h>
-#include <utils/variant.h>
 
 #include <QTextCursor>
 #include <QJsonObject>
@@ -42,6 +41,7 @@
 #include <QList>
 
 #include <functional>
+#include <variant>
 
 namespace LanguageServerProtocol {
 
@@ -190,7 +190,7 @@ public:
     void clearSeverity() { remove(severityKey); }
 
     // The diagnostic's code, which might appear in the user interface.
-    using Code = Utils::variant<int, QString>;
+    using Code = std::variant<int, QString>;
     Utils::optional<Code> code() const;
     void setCode(const Code &code);
     void clearCode() { remove(codeKey); }
@@ -456,11 +456,11 @@ public:
     { return contains(kindKey) && contains(contentKey); }
 };
 
-class LANGUAGESERVERPROTOCOL_EXPORT MarkupOrString : public Utils::variant<QString, MarkupContent>
+class LANGUAGESERVERPROTOCOL_EXPORT MarkupOrString : public std::variant<QString, MarkupContent>
 {
 public:
     MarkupOrString() = default;
-    explicit MarkupOrString(const Utils::variant<QString, MarkupContent> &val);
+    explicit MarkupOrString(const std::variant<QString, MarkupContent> &val);
     explicit MarkupOrString(const QString &val);
     explicit MarkupOrString(const MarkupContent &val);
     MarkupOrString(const QJsonValue &val);
diff --git a/src/libs/languageserverprotocol/lsputils.h b/src/libs/languageserverprotocol/lsputils.h
index 47352ff6bb..4d073cddbd 100644
--- a/src/libs/languageserverprotocol/lsputils.h
+++ b/src/libs/languageserverprotocol/lsputils.h
@@ -30,12 +30,13 @@
 #include <utils/algorithm.h>
 #include <utils/optional.h>
 #include <utils/qtcassert.h>
-#include <utils/variant.h>
 
 #include <QJsonArray>
 #include <QJsonObject>
 #include <QLoggingCategory>
 
+#include <variant>
+
 namespace LanguageServerProtocol {
 
 LANGUAGESERVERPROTOCOL_EXPORT Q_DECLARE_LOGGING_CATEGORY(conversionLog)
@@ -73,11 +74,11 @@ template<>
 LANGUAGESERVERPROTOCOL_EXPORT QJsonValue fromJsonValue<QJsonValue>(const QJsonValue &value);
 
 template <typename T>
-class LanguageClientArray : public Utils::variant<QList<T>, std::nullptr_t>
+class LanguageClientArray : public std::variant<QList<T>, std::nullptr_t>
 {
 public:
-    using Utils::variant<QList<T>, std::nullptr_t>::variant;
-    using Utils::variant<QList<T>, std::nullptr_t>::operator=;
+    using std::variant<QList<T>, std::nullptr_t>::variant;
+    using std::variant<QList<T>, std::nullptr_t>::operator=;
 
     LanguageClientArray() {}
 
@@ -99,7 +100,7 @@ public:
 
     QJsonValue toJson() const
     {
-        if (const auto list = Utils::get_if<QList<T>>(this)) {
+        if (const auto list = std::get_if<QList<T>>(this)) {
             QJsonArray array;
             for (const T &value : *list)
                 array.append(QJsonValue(value));
@@ -110,20 +111,20 @@ public:
 
     QList<T> toList() const
     {
-        QTC_ASSERT(Utils::holds_alternative<QList<T>>(*this), return {});
-        return Utils::get<QList<T>>(*this);
+        QTC_ASSERT(std::holds_alternative<QList<T>>(*this), return {});
+        return std::get<QList<T>>(*this);
     }
-    bool isNull() const { return Utils::holds_alternative<std::nullptr_t>(*this); }
+    bool isNull() const { return std::holds_alternative<std::nullptr_t>(*this); }
 };
 
 template <typename T>
-class LanguageClientValue : public Utils::variant<T, std::nullptr_t>
+class LanguageClientValue : public std::variant<T, std::nullptr_t>
 {
 public:
-    using Utils::variant<T, std::nullptr_t>::operator=;
+    using std::variant<T, std::nullptr_t>::operator=;
 
-    LanguageClientValue() : Utils::variant<T, std::nullptr_t>(nullptr) { }
-    LanguageClientValue(const T &value) : Utils::variant<T, std::nullptr_t>(value) { }
+    LanguageClientValue() : std::variant<T, std::nullptr_t>(nullptr) { }
+    LanguageClientValue(const T &value) : std::variant<T, std::nullptr_t>(value) { }
     LanguageClientValue(const QJsonValue &value)
     {
         if (!QTC_GUARD(!value.isUndefined()) || value.isNull())
@@ -134,25 +135,25 @@ public:
 
     operator const QJsonValue() const
     {
-        if (auto val = Utils::get_if<T>(this))
+        if (auto val = std::get_if<T>(this))
             return QJsonValue(*val);
         return QJsonValue();
     }
 
     T value(const T &defaultValue = T()) const
     {
-        QTC_ASSERT(Utils::holds_alternative<T>(*this), return defaultValue);
-        return Utils::get<T>(*this);
+        QTC_ASSERT(std::holds_alternative<T>(*this), return defaultValue);
+        return std::get<T>(*this);
     }
 
     template<typename Type>
     LanguageClientValue<Type> transform()
     {
-        QTC_ASSERT(!Utils::holds_alternative<T>(*this), return LanguageClientValue<Type>());
-        return Type(Utils::get<T>(*this));
+        QTC_ASSERT(!std::holds_alternative<T>(*this), return LanguageClientValue<Type>());
+        return Type(std::get<T>(*this));
     }
 
-    bool isNull() const { return Utils::holds_alternative<std::nullptr_t>(*this); }
+    bool isNull() const { return std::holds_alternative<std::nullptr_t>(*this); }
 };
 
 template <typename T>
diff --git a/src/libs/languageserverprotocol/progresssupport.cpp b/src/libs/languageserverprotocol/progresssupport.cpp
index 479a48489a..5802d5169d 100644
--- a/src/libs/languageserverprotocol/progresssupport.cpp
+++ b/src/libs/languageserverprotocol/progresssupport.cpp
@@ -43,9 +43,9 @@ ProgressToken::ProgressToken(const QJsonValue &value)
 
 ProgressToken::operator QJsonValue() const
 {
-    if (Utils::holds_alternative<QString>(*this))
-        return QJsonValue(Utils::get<QString>(*this));
-    return QJsonValue(Utils::get<int>(*this));
+    if (std::holds_alternative<QString>(*this))
+        return QJsonValue(std::get<QString>(*this));
+    return QJsonValue(std::get<int>(*this));
 }
 
 ProgressParams::ProgressType ProgressParams::value() const
diff --git a/src/libs/languageserverprotocol/progresssupport.h b/src/libs/languageserverprotocol/progresssupport.h
index 65cead4287..df480ef69a 100644
--- a/src/libs/languageserverprotocol/progresssupport.h
+++ b/src/libs/languageserverprotocol/progresssupport.h
@@ -27,13 +27,13 @@
 
 #include "jsonrpcmessages.h"
 
-#include <utils/variant.h>
-
 #include <QJsonValue>
 
+#include <variant>
+
 namespace LanguageServerProtocol {
 
-class LANGUAGESERVERPROTOCOL_EXPORT ProgressToken : public Utils::variant<int, QString>
+class LANGUAGESERVERPROTOCOL_EXPORT ProgressToken : public std::variant<int, QString>
 {
 public:
     using variant::variant;
@@ -124,7 +124,7 @@ public:
     void setToken(const ProgressToken &token) { insert(tokenKey, token); }
 
     using ProgressType
-        = Utils::variant<WorkDoneProgressBegin, WorkDoneProgressReport, WorkDoneProgressEnd>;
+        = std::variant<WorkDoneProgressBegin, WorkDoneProgressReport, WorkDoneProgressEnd>;
     ProgressType value() const;
     void setValue(const ProgressType &value);
 
diff --git a/src/libs/languageserverprotocol/semantictokens.h b/src/libs/languageserverprotocol/semantictokens.h
index cc561ec670..1010a4582a 100644
--- a/src/libs/languageserverprotocol/semantictokens.h
+++ b/src/libs/languageserverprotocol/semantictokens.h
@@ -164,7 +164,7 @@ public:
 };
 
 class LANGUAGESERVERPROTOCOL_EXPORT SemanticTokensResult
-    : public Utils::variant<SemanticTokens, std::nullptr_t>
+    : public std::variant<SemanticTokens, std::nullptr_t>
 {
 public:
     using variant::variant;
@@ -215,7 +215,7 @@ public:
 };
 
 class LANGUAGESERVERPROTOCOL_EXPORT SemanticTokensDeltaResult
-    : public Utils::variant<SemanticTokens, SemanticTokensDelta, std::nullptr_t>
+    : public std::variant<SemanticTokens, SemanticTokensDelta, std::nullptr_t>
 {
 public:
     using variant::variant;
diff --git a/src/libs/languageserverprotocol/servercapabilities.cpp b/src/libs/languageserverprotocol/servercapabilities.cpp
index dd2b7628eb..908d4374d0 100644
--- a/src/libs/languageserverprotocol/servercapabilities.cpp
+++ b/src/libs/languageserverprotocol/servercapabilities.cpp
@@ -44,9 +44,9 @@ void ServerCapabilities::setTextDocumentSync(const ServerCapabilities::TextDocum
 TextDocumentSyncKind ServerCapabilities::textDocumentSyncKindHelper()
 {
     if (Utils::optional<TextDocumentSync> sync = textDocumentSync()) {
-        if (auto kind = Utils::get_if<int>(&*sync))
+        if (auto kind = std::get_if<int>(&*sync))
             return static_cast<TextDocumentSyncKind>(*kind);
-        if (auto options = Utils::get_if<TextDocumentSyncOptions>(&*sync)) {
+        if (auto options = std::get_if<TextDocumentSyncOptions>(&*sync)) {
             if (const Utils::optional<int> &change = options->change())
                 return static_cast<TextDocumentSyncKind>(*change);
         }
@@ -54,10 +54,10 @@ TextDocumentSyncKind ServerCapabilities::textDocumentSyncKindHelper()
     return TextDocumentSyncKind::None;
 }
 
-Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>> ServerCapabilities::hoverProvider()
+Utils::optional<std::variant<bool, WorkDoneProgressOptions>> ServerCapabilities::hoverProvider()
     const
 {
-    using RetType = Utils::variant<bool, WorkDoneProgressOptions>;
+    using RetType = std::variant<bool, WorkDoneProgressOptions>;
     const QJsonValue &provider = value(hoverProviderKey);
     if (provider.isBool())
         return Utils::make_optional(RetType(provider.toBool()));
@@ -67,15 +67,15 @@ Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>> ServerCapabilitie
 }
 
 void ServerCapabilities::setHoverProvider(
-    const Utils::variant<bool, WorkDoneProgressOptions> &hoverProvider)
+    const std::variant<bool, WorkDoneProgressOptions> &hoverProvider)
 {
     insertVariant<bool, WorkDoneProgressOptions>(hoverProviderKey, hoverProvider);
 }
 
-Utils::optional<Utils::variant<bool, ServerCapabilities::RegistrationOptions>>
+Utils::optional<std::variant<bool, ServerCapabilities::RegistrationOptions>>
 ServerCapabilities::typeDefinitionProvider() const
 {
-    using RetType = Utils::variant<bool, ServerCapabilities::RegistrationOptions>;
+    using RetType = std::variant<bool, ServerCapabilities::RegistrationOptions>;
     const QJsonValue &provider = value(typeDefinitionProviderKey);
     if (provider.isUndefined() || !(provider.isBool() || provider.isObject()))
         return Utils::nullopt;
@@ -84,16 +84,16 @@ ServerCapabilities::typeDefinitionProvider() const
 }
 
 void ServerCapabilities::setTypeDefinitionProvider(
-        const Utils::variant<bool, ServerCapabilities::RegistrationOptions> &typeDefinitionProvider)
+        const std::variant<bool, ServerCapabilities::RegistrationOptions> &typeDefinitionProvider)
 {
     insertVariant<bool, ServerCapabilities::RegistrationOptions>(typeDefinitionProviderKey,
                                                                  typeDefinitionProvider);
 }
 
-Utils::optional<Utils::variant<bool, ServerCapabilities::RegistrationOptions>>
+Utils::optional<std::variant<bool, ServerCapabilities::RegistrationOptions>>
 ServerCapabilities::implementationProvider() const
 {
-    using RetType = Utils::variant<bool, ServerCapabilities::RegistrationOptions>;
+    using RetType = std::variant<bool, ServerCapabilities::RegistrationOptions>;
     const QJsonValue &provider = value(implementationProviderKey);
     if (provider.isUndefined() || !(provider.isBool() || provider.isObject()))
         return Utils::nullopt;
@@ -102,15 +102,15 @@ ServerCapabilities::implementationProvider() const
 }
 
 void ServerCapabilities::setImplementationProvider(
-        const Utils::variant<bool, ServerCapabilities::RegistrationOptions> &implementationProvider)
+        const std::variant<bool, ServerCapabilities::RegistrationOptions> &implementationProvider)
 {
     insertVariant<bool, RegistrationOptions>(implementationProviderKey, implementationProvider);
 }
 
-Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>>
+Utils::optional<std::variant<bool, WorkDoneProgressOptions>>
 ServerCapabilities::referencesProvider() const
 {
-    using RetType = Utils::variant<bool, WorkDoneProgressOptions>;
+    using RetType = std::variant<bool, WorkDoneProgressOptions>;
     const QJsonValue &provider = value(referencesProviderKey);
     if (provider.isBool())
         return Utils::make_optional(RetType(provider.toBool()));
@@ -120,16 +120,16 @@ ServerCapabilities::referencesProvider() const
 }
 
 void ServerCapabilities::setReferencesProvider(
-    const Utils::variant<bool, WorkDoneProgressOptions> &referencesProvider)
+    const std::variant<bool, WorkDoneProgressOptions> &referencesProvider)
 {
     insertVariant<bool, WorkDoneProgressOptions>(referencesProviderKey,
                                                  referencesProvider);
 }
 
-Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>>
+Utils::optional<std::variant<bool, WorkDoneProgressOptions>>
 ServerCapabilities::documentHighlightProvider() const
 {
-    using RetType = Utils::variant<bool, WorkDoneProgressOptions>;
+    using RetType = std::variant<bool, WorkDoneProgressOptions>;
     const QJsonValue &provider = value(documentHighlightProviderKey);
     if (provider.isBool())
         return Utils::make_optional(RetType(provider.toBool()));
@@ -139,16 +139,16 @@ ServerCapabilities::documentHighlightProvider() const
 }
 
 void ServerCapabilities::setDocumentHighlightProvider(
-    const Utils::variant<bool, WorkDoneProgressOptions> &documentHighlightProvider)
+    const std::variant<bool, WorkDoneProgressOptions> &documentHighlightProvider)
 {
     insertVariant<bool, WorkDoneProgressOptions>(documentHighlightProviderKey,
                                                  documentHighlightProvider);
 }
 
-Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>>
+Utils::optional<std::variant<bool, WorkDoneProgressOptions>>
 ServerCapabilities::documentSymbolProvider() const
 {
-    using RetType = Utils::variant<bool, WorkDoneProgressOptions>;
+    using RetType = std::variant<bool, WorkDoneProgressOptions>;
     const QJsonValue &provider = value(documentSymbolProviderKey);
     if (provider.isBool())
         return Utils::make_optional(RetType(provider.toBool()));
@@ -158,7 +158,7 @@ ServerCapabilities::documentSymbolProvider() const
 }
 
 void ServerCapabilities::setDocumentSymbolProvider(
-    Utils::variant<bool, WorkDoneProgressOptions> documentSymbolProvider)
+    std::variant<bool, WorkDoneProgressOptions> documentSymbolProvider)
 {
     insertVariant<bool, WorkDoneProgressOptions>(documentSymbolProviderKey,
                                                  documentSymbolProvider);
@@ -175,10 +175,10 @@ void ServerCapabilities::setSemanticTokensProvider(
     insert(semanticTokensProviderKey, semanticTokensProvider);
 }
 
-Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>>
+Utils::optional<std::variant<bool, WorkDoneProgressOptions>>
 ServerCapabilities::workspaceSymbolProvider() const
 {
-    using RetType = Utils::variant<bool, WorkDoneProgressOptions>;
+    using RetType = std::variant<bool, WorkDoneProgressOptions>;
     const QJsonValue &provider = value(workspaceSymbolProviderKey);
     if (provider.isBool())
         return Utils::make_optional(RetType(provider.toBool()));
@@ -188,29 +188,29 @@ ServerCapabilities::workspaceSymbolProvider() const
 }
 
 void ServerCapabilities::setWorkspaceSymbolProvider(
-    Utils::variant<bool, WorkDoneProgressOptions> workspaceSymbolProvider)
+    std::variant<bool, WorkDoneProgressOptions> workspaceSymbolProvider)
 {
     insertVariant<bool, WorkDoneProgressOptions>(workspaceSymbolProviderKey,
                                                  workspaceSymbolProvider);
 }
 
-Utils::optional<Utils::variant<bool, CodeActionOptions>> ServerCapabilities::codeActionProvider() const
+Utils::optional<std::variant<bool, CodeActionOptions>> ServerCapabilities::codeActionProvider() const
 {
     const QJsonValue &provider = value(codeActionProviderKey);
     if (provider.isBool())
-        return Utils::make_optional(Utils::variant<bool, CodeActionOptions>(provider.toBool()));
+        return Utils::make_optional(std::variant<bool, CodeActionOptions>(provider.toBool()));
     if (provider.isObject()) {
         CodeActionOptions options(provider);
         if (options.isValid())
-            return Utils::make_optional(Utils::variant<bool, CodeActionOptions>(options));
+            return Utils::make_optional(std::variant<bool, CodeActionOptions>(options));
     }
     return Utils::nullopt;
 }
 
-Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>>
+Utils::optional<std::variant<bool, WorkDoneProgressOptions>>
 ServerCapabilities::documentFormattingProvider() const
 {
-    using RetType = Utils::variant<bool, WorkDoneProgressOptions>;
+    using RetType = std::variant<bool, WorkDoneProgressOptions>;
     const QJsonValue &provider = value(documentFormattingProviderKey);
     if (provider.isBool())
         return Utils::make_optional(RetType(provider.toBool()));
@@ -220,16 +220,16 @@ ServerCapabilities::documentFormattingProvider() const
 }
 
 void ServerCapabilities::setDocumentFormattingProvider(
-    const Utils::variant<bool, WorkDoneProgressOptions> &documentFormattingProvider)
+    const std::variant<bool, WorkDoneProgressOptions> &documentFormattingProvider)
 {
     insertVariant<bool, WorkDoneProgressOptions>(documentFormattingProviderKey,
                                                  documentFormattingProvider);
 }
 
-Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>>
+Utils::optional<std::variant<bool, WorkDoneProgressOptions>>
 ServerCapabilities::documentRangeFormattingProvider() const
 {
-    using RetType = Utils::variant<bool, WorkDoneProgressOptions>;
+    using RetType = std::variant<bool, WorkDoneProgressOptions>;
     const QJsonValue &provider = value(documentRangeFormattingProviderKey);
     if (provider.isBool())
         return Utils::make_optional(RetType(provider.toBool()));
@@ -239,15 +239,15 @@ ServerCapabilities::documentRangeFormattingProvider() const
 }
 
 void ServerCapabilities::setDocumentRangeFormattingProvider(
-    Utils::variant<bool, WorkDoneProgressOptions> documentRangeFormattingProvider)
+    std::variant<bool, WorkDoneProgressOptions> documentRangeFormattingProvider)
 {
     insertVariant<bool, WorkDoneProgressOptions>(documentRangeFormattingProviderKey,
                                                  documentRangeFormattingProvider);
 }
 
-Utils::optional<Utils::variant<ServerCapabilities::RenameOptions, bool>> ServerCapabilities::renameProvider() const
+Utils::optional<std::variant<ServerCapabilities::RenameOptions, bool>> ServerCapabilities::renameProvider() const
 {
-    using RetType = Utils::variant<ServerCapabilities::RenameOptions, bool>;
+    using RetType = std::variant<ServerCapabilities::RenameOptions, bool>;
     const QJsonValue &localValue = value(renameProviderKey);
     if (localValue.isBool())
         return RetType(localValue.toBool());
@@ -256,14 +256,14 @@ Utils::optional<Utils::variant<ServerCapabilities::RenameOptions, bool>> ServerC
     return Utils::nullopt;
 }
 
-void ServerCapabilities::setRenameProvider(Utils::variant<ServerCapabilities::RenameOptions, bool> renameProvider)
+void ServerCapabilities::setRenameProvider(std::variant<ServerCapabilities::RenameOptions, bool> renameProvider)
 {
     insertVariant<RenameOptions, bool>(renameProviderKey, renameProvider);
 }
 
-Utils::optional<Utils::variant<bool, JsonObject>> ServerCapabilities::colorProvider() const
+Utils::optional<std::variant<bool, JsonObject>> ServerCapabilities::colorProvider() const
 {
-    using RetType = Utils::variant<bool, JsonObject>;
+    using RetType = std::variant<bool, JsonObject>;
     const QJsonValue &localValue = value(colorProviderKey);
     if (localValue.isBool())
         return RetType(localValue.toBool());
@@ -272,15 +272,15 @@ Utils::optional<Utils::variant<bool, JsonObject>> ServerCapabilities::colorProvi
     return Utils::nullopt;
 }
 
-void ServerCapabilities::setColorProvider(Utils::variant<bool, JsonObject> colorProvider)
+void ServerCapabilities::setColorProvider(std::variant<bool, JsonObject> colorProvider)
 {
     insertVariant<bool, JsonObject>(renameProviderKey, colorProvider);
 }
 
-Utils::optional<Utils::variant<QString, bool> >
+Utils::optional<std::variant<QString, bool> >
 ServerCapabilities::WorkspaceServerCapabilities::WorkspaceFoldersCapabilities::changeNotifications() const
 {
-    using RetType = Utils::variant<QString, bool>;
+    using RetType = std::variant<QString, bool>;
     const QJsonValue &change = value(changeNotificationsKey);
     if (change.isUndefined())
         return Utils::nullopt;
@@ -289,7 +289,7 @@ ServerCapabilities::WorkspaceServerCapabilities::WorkspaceFoldersCapabilities::c
 }
 
 void ServerCapabilities::WorkspaceServerCapabilities::WorkspaceFoldersCapabilities::setChangeNotifications(
-        Utils::variant<QString, bool> changeNotifications)
+        std::variant<QString, bool> changeNotifications)
 {
     insertVariant<QString, bool>(changeNotificationsKey, changeNotifications);
 }
@@ -315,9 +315,9 @@ bool CodeActionOptions::isValid() const
     return WorkDoneProgressOptions::isValid() && contains(codeActionKindsKey);
 }
 
-Utils::optional<Utils::variant<bool, QJsonObject>> SemanticTokensOptions::range() const
+Utils::optional<std::variant<bool, QJsonObject>> SemanticTokensOptions::range() const
 {
-    using RetType = Utils::variant<bool, QJsonObject>;
+    using RetType = std::variant<bool, QJsonObject>;
     const QJsonValue &rangeOptions = value(rangeKey);
     if (rangeOptions.isBool())
         return RetType(rangeOptions.toBool());
@@ -326,15 +326,15 @@ Utils::optional<Utils::variant<bool, QJsonObject>> SemanticTokensOptions::range(
     return Utils::nullopt;
 }
 
-void SemanticTokensOptions::setRange(const Utils::variant<bool, QJsonObject> &range)
+void SemanticTokensOptions::setRange(const std::variant<bool, QJsonObject> &range)
 {
     insertVariant<bool, QJsonObject>(rangeKey, range);
 }
 
-Utils::optional<Utils::variant<bool, SemanticTokensOptions::FullSemanticTokenOptions>>
+Utils::optional<std::variant<bool, SemanticTokensOptions::FullSemanticTokenOptions>>
 SemanticTokensOptions::full() const
 {
-    using RetType = Utils::variant<bool, SemanticTokensOptions::FullSemanticTokenOptions>;
+    using RetType = std::variant<bool, SemanticTokensOptions::FullSemanticTokenOptions>;
     const QJsonValue &fullOptions = value(fullKey);
     if (fullOptions.isBool())
         return RetType(fullOptions.toBool());
@@ -344,7 +344,7 @@ SemanticTokensOptions::full() const
 }
 
 void SemanticTokensOptions::setFull(
-    const Utils::variant<bool, SemanticTokensOptions::FullSemanticTokenOptions> &full)
+    const std::variant<bool, SemanticTokensOptions::FullSemanticTokenOptions> &full)
 {
     insertVariant<bool, FullSemanticTokenOptions>(fullKey, full);
 }
diff --git a/src/libs/languageserverprotocol/servercapabilities.h b/src/libs/languageserverprotocol/servercapabilities.h
index 7cc1b708fc..14c8d60e78 100644
--- a/src/libs/languageserverprotocol/servercapabilities.h
+++ b/src/libs/languageserverprotocol/servercapabilities.h
@@ -152,8 +152,8 @@ public:
     void setLegend(const SemanticTokensLegend &legend) { insert(legendKey, legend); }
 
     /// Server supports providing semantic tokens for a specific range of a document.
-    Utils::optional<Utils::variant<bool, QJsonObject>> range() const;
-    void setRange(const Utils::variant<bool, QJsonObject> &range);
+    Utils::optional<std::variant<bool, QJsonObject>> range() const;
+    void setRange(const std::variant<bool, QJsonObject> &range);
     void clearRange() { remove(rangeKey); }
 
     class FullSemanticTokenOptions : public JsonObject
@@ -168,8 +168,8 @@ public:
     };
 
     /// Server supports providing semantic tokens for a full document.
-    Utils::optional<Utils::variant<bool, FullSemanticTokenOptions>> full() const;
-    void setFull(const Utils::variant<bool, FullSemanticTokenOptions> &full);
+    Utils::optional<std::variant<bool, FullSemanticTokenOptions>> full() const;
+    void setFull(const std::variant<bool, FullSemanticTokenOptions> &full);
     void clearFull() { remove(fullKey); }
 
     bool isValid() const override { return contains(legendKey); }
@@ -265,7 +265,7 @@ public:
 
     // Defines how text documents are synced. Is either a detailed structure defining each
     // notification or for backwards compatibility the TextDocumentSyncKind number.
-    using TextDocumentSync = Utils::variant<TextDocumentSyncOptions, int>;
+    using TextDocumentSync = std::variant<TextDocumentSyncOptions, int>;
     Utils::optional<TextDocumentSync> textDocumentSync() const;
     void setTextDocumentSync(const TextDocumentSync &textDocumentSync);
     void clearTextDocumentSync() { remove(textDocumentSyncKey); }
@@ -273,8 +273,8 @@ public:
     TextDocumentSyncKind textDocumentSyncKindHelper();
 
     // The server provides hover support.
-    Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>> hoverProvider() const;
-    void setHoverProvider(const Utils::variant<bool, WorkDoneProgressOptions> &hoverProvider);
+    Utils::optional<std::variant<bool, WorkDoneProgressOptions>> hoverProvider() const;
+    void setHoverProvider(const std::variant<bool, WorkDoneProgressOptions> &hoverProvider);
     void clearHoverProvider() { remove(hoverProviderKey); }
 
     // The server provides completion support.
@@ -321,29 +321,29 @@ public:
     };
 
     // The server provides Goto Type Definition support.
-    Utils::optional<Utils::variant<bool, RegistrationOptions>> typeDefinitionProvider() const;
-    void setTypeDefinitionProvider(const Utils::variant<bool, RegistrationOptions> &typeDefinitionProvider);
+    Utils::optional<std::variant<bool, RegistrationOptions>> typeDefinitionProvider() const;
+    void setTypeDefinitionProvider(const std::variant<bool, RegistrationOptions> &typeDefinitionProvider);
     void clearTypeDefinitionProvider() { remove(typeDefinitionProviderKey); }
 
     // The server provides Goto Implementation support.
-    Utils::optional<Utils::variant<bool, RegistrationOptions>> implementationProvider() const;
-    void setImplementationProvider(const Utils::variant<bool, RegistrationOptions> &implementationProvider);
+    Utils::optional<std::variant<bool, RegistrationOptions>> implementationProvider() const;
+    void setImplementationProvider(const std::variant<bool, RegistrationOptions> &implementationProvider);
     void clearImplementationProvider() { remove(implementationProviderKey); }
 
     // The server provides find references support.
-    Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>> referencesProvider() const;
-    void setReferencesProvider(const Utils::variant<bool, WorkDoneProgressOptions> &referencesProvider);
+    Utils::optional<std::variant<bool, WorkDoneProgressOptions>> referencesProvider() const;
+    void setReferencesProvider(const std::variant<bool, WorkDoneProgressOptions> &referencesProvider);
     void clearReferencesProvider() { remove(referencesProviderKey); }
 
     // The server provides document highlight support.
-    Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>> documentHighlightProvider() const;
+    Utils::optional<std::variant<bool, WorkDoneProgressOptions>> documentHighlightProvider() const;
     void setDocumentHighlightProvider(
-        const Utils::variant<bool, WorkDoneProgressOptions> &documentHighlightProvider);
+        const std::variant<bool, WorkDoneProgressOptions> &documentHighlightProvider);
     void clearDocumentHighlightProvider() { remove(documentHighlightProviderKey); }
 
     // The server provides document symbol support.
-    Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>> documentSymbolProvider() const;
-    void setDocumentSymbolProvider(Utils::variant<bool, WorkDoneProgressOptions> documentSymbolProvider);
+    Utils::optional<std::variant<bool, WorkDoneProgressOptions>> documentSymbolProvider() const;
+    void setDocumentSymbolProvider(std::variant<bool, WorkDoneProgressOptions> documentSymbolProvider);
     void clearDocumentSymbolProvider() { remove(documentSymbolProviderKey); }
 
     Utils::optional<SemanticTokensOptions> semanticTokensProvider() const;
@@ -351,12 +351,12 @@ public:
     void clearSemanticTokensProvider() { remove(semanticTokensProviderKey); }
 
     // The server provides workspace symbol support.
-    Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>> workspaceSymbolProvider() const;
-    void setWorkspaceSymbolProvider(Utils::variant<bool, WorkDoneProgressOptions> workspaceSymbolProvider);
+    Utils::optional<std::variant<bool, WorkDoneProgressOptions>> workspaceSymbolProvider() const;
+    void setWorkspaceSymbolProvider(std::variant<bool, WorkDoneProgressOptions> workspaceSymbolProvider);
     void clearWorkspaceSymbolProvider() { remove(workspaceSymbolProviderKey); }
 
     // The server provides code actions.
-    Utils::optional<Utils::variant<bool, CodeActionOptions>> codeActionProvider() const;
+    Utils::optional<std::variant<bool, CodeActionOptions>> codeActionProvider() const;
     void setCodeActionProvider(bool codeActionProvider)
     { insert(codeActionProviderKey, codeActionProvider); }
     void setCodeActionProvider(CodeActionOptions options)
@@ -371,14 +371,14 @@ public:
     void clearCodeLensProvider() { remove(codeLensProviderKey); }
 
     // The server provides document formatting.
-    Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>> documentFormattingProvider() const;
+    Utils::optional<std::variant<bool, WorkDoneProgressOptions>> documentFormattingProvider() const;
     void setDocumentFormattingProvider(
-        const Utils::variant<bool, WorkDoneProgressOptions> &documentFormattingProvider);
+        const std::variant<bool, WorkDoneProgressOptions> &documentFormattingProvider);
     void clearDocumentFormattingProvider() { remove(documentFormattingProviderKey); }
 
     // The server provides document formatting on typing.
-    Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>> documentRangeFormattingProvider() const;
-    void setDocumentRangeFormattingProvider(Utils::variant<bool, WorkDoneProgressOptions> documentRangeFormattingProvider);
+    Utils::optional<std::variant<bool, WorkDoneProgressOptions>> documentRangeFormattingProvider() const;
+    void setDocumentRangeFormattingProvider(std::variant<bool, WorkDoneProgressOptions> documentRangeFormattingProvider);
     void clearDocumentRangeFormattingProvider() { remove(documentRangeFormattingProviderKey); }
 
     class LANGUAGESERVERPROTOCOL_EXPORT RenameOptions : public WorkDoneProgressOptions
@@ -393,8 +393,8 @@ public:
     };
 
     // The server provides rename support.
-    Utils::optional<Utils::variant<RenameOptions, bool>> renameProvider() const;
-    void setRenameProvider(Utils::variant<RenameOptions,bool> renameProvider);
+    Utils::optional<std::variant<RenameOptions, bool>> renameProvider() const;
+    void setRenameProvider(std::variant<RenameOptions,bool> renameProvider);
     void clearRenameProvider() { remove(renameProviderKey); }
 
     // The server provides document link support.
@@ -405,8 +405,8 @@ public:
     void clearDocumentLinkProvider() { remove(documentLinkProviderKey); }
 
     // The server provides color provider support.
-    Utils::optional<Utils::variant<bool, JsonObject>> colorProvider() const;
-    void setColorProvider(Utils::variant<bool, JsonObject> colorProvider);
+    Utils::optional<std::variant<bool, JsonObject>> colorProvider() const;
+    void setColorProvider(std::variant<bool, JsonObject> colorProvider);
     void clearColorProvider() { remove(colorProviderKey); }
 
     // The server provides execute command support.
@@ -431,8 +431,8 @@ public:
             void setSupported(bool supported) { insert(supportedKey, supported); }
             void clearSupported() { remove(supportedKey); }
 
-            Utils::optional<Utils::variant<QString, bool>> changeNotifications() const;
-            void setChangeNotifications(Utils::variant<QString, bool> changeNotifications);
+            Utils::optional<std::variant<QString, bool>> changeNotifications() const;
+            void setChangeNotifications(std::variant<QString, bool> changeNotifications);
             void clearChangeNotifications() { remove(changeNotificationsKey); }
         };
 
diff --git a/src/libs/languageserverprotocol/workspace.cpp b/src/libs/languageserverprotocol/workspace.cpp
index 3244a96bbf..c26b08f428 100644
--- a/src/libs/languageserverprotocol/workspace.cpp
+++ b/src/libs/languageserverprotocol/workspace.cpp
@@ -86,10 +86,10 @@ ExecuteCommandParams::ExecuteCommandParams(const Command &command)
 
 LanguageServerProtocol::WorkSpaceFolderResult::operator const QJsonValue() const
 {
-    if (!Utils::holds_alternative<QList<WorkSpaceFolder>>(*this))
+    if (!std::holds_alternative<QList<WorkSpaceFolder>>(*this))
         return QJsonValue::Null;
     QJsonArray array;
-    for (const auto &folder : Utils::get<QList<WorkSpaceFolder>>(*this))
+    for (const auto &folder : std::get<QList<WorkSpaceFolder>>(*this))
         array.append(QJsonValue(folder));
     return array;
 }
diff --git a/src/libs/languageserverprotocol/workspace.h b/src/libs/languageserverprotocol/workspace.h
index 6179cd7000..bc3c3bcb0a 100644
--- a/src/libs/languageserverprotocol/workspace.h
+++ b/src/libs/languageserverprotocol/workspace.h
@@ -30,7 +30,7 @@
 namespace LanguageServerProtocol {
 
 class LANGUAGESERVERPROTOCOL_EXPORT WorkSpaceFolderResult
-    : public Utils::variant<QList<WorkSpaceFolder>, std::nullptr_t>
+    : public std::variant<QList<WorkSpaceFolder>, std::nullptr_t>
 {
 public:
     using variant::variant;
diff --git a/src/libs/nanotrace/nanotrace.cpp b/src/libs/nanotrace/nanotrace.cpp
index d6e6ca30a3..36c7fd7459 100644
--- a/src/libs/nanotrace/nanotrace.cpp
+++ b/src/libs/nanotrace/nanotrace.cpp
@@ -60,7 +60,7 @@ struct ConvertArgValueToString {
 
 std::string Arg::value() const
 {
-    return Utils::visit(ConvertArgValueToString(), m_value);
+    return std::visit(ConvertArgValueToString(), m_value);
 }
 
 
diff --git a/src/libs/nanotrace/nanotrace.h b/src/libs/nanotrace/nanotrace.h
index e71e6e8c19..017678e613 100644
--- a/src/libs/nanotrace/nanotrace.h
+++ b/src/libs/nanotrace/nanotrace.h
@@ -33,13 +33,11 @@
 #  define NANOTRACESHARED_EXPORT Q_DECL_IMPORT
 #endif
 
-#include <utils/variant.h> // revert when macos minimum target is >= 10.14
-
 #include <chrono>
 #include <string>
+#include <variant>
 #include <vector>
 
-
 #ifdef NANOTRACE_ENABLED
 
 #define NANOTRACE_INIT(process, thread, filepath) Nanotrace::init(process, thread, filepath)
@@ -81,7 +79,7 @@ using TimePoint = std::chrono::time_point< Clock >;
 class NANOTRACESHARED_EXPORT Arg
 {
 public:
-    using SupportedType = Utils::variant<int, int64_t, double, std::string>;
+    using SupportedType = std::variant<int, int64_t, double, std::string>;
 
     Arg(const std::string &name, const SupportedType &val);
     std::string name() const;
diff --git a/src/libs/sqlite/constraints.h b/src/libs/sqlite/constraints.h
index c8e1ecf7d7..700dd0ecb3 100644
--- a/src/libs/sqlite/constraints.h
+++ b/src/libs/sqlite/constraints.h
@@ -29,7 +29,8 @@
 
 #include <sqlitevalue.h>
 #include <utils/smallstring.h>
-#include <utils/variant.h>
+
+#include <variant>
 
 namespace Sqlite {
 
@@ -179,7 +180,7 @@ public:
     GeneratedAlwaysStorage storage = {};
 };
 
-using Constraint = Utils::variant<Unique,
+using Constraint = std::variant<Unique,
                                   PrimaryKey,
                                   ForeignKey,
                                   NotNull,
diff --git a/src/libs/sqlite/createtablesqlstatementbuilder.h b/src/libs/sqlite/createtablesqlstatementbuilder.h
index 588da02d86..cf24b688b9 100644
--- a/src/libs/sqlite/createtablesqlstatementbuilder.h
+++ b/src/libs/sqlite/createtablesqlstatementbuilder.h
@@ -294,7 +294,7 @@ private:
             ContraintsVisiter visiter{columnDefinitionString};
 
             for (const Constraint &constraint : column.constraints)
-                Utils::visit(visiter, constraint);
+                std::visit(visiter, constraint);
 
             columnDefinitionStrings.push_back(std::move(columnDefinitionString));
         }
@@ -303,7 +303,7 @@ private:
             Utils::SmallString columnDefinitionString;
 
             TableContraintsVisiter visiter{columnDefinitionString};
-            Utils::visit(visiter, constraint);
+            std::visit(visiter, constraint);
 
             columnDefinitionStrings.push_back(std::move(columnDefinitionString));
         }
diff --git a/src/libs/sqlite/sqlitetable.h b/src/libs/sqlite/sqlitetable.h
index 2df39f4342..6e7d09f019 100644
--- a/src/libs/sqlite/sqlitetable.h
+++ b/src/libs/sqlite/sqlitetable.h
@@ -201,8 +201,8 @@ public:
         return std::find_if(constraints.begin(),
                             constraints.end(),
                             [](const Constraint &constraint) {
-                                return Utils::holds_alternative<Unique>(constraint)
-                                       || Utils::holds_alternative<PrimaryKey>(constraint);
+                                return std::holds_alternative<Unique>(constraint)
+                                       || std::holds_alternative<PrimaryKey>(constraint);
                             })
                != constraints.end();
     }
diff --git a/src/libs/sqlite/sqlitevalue.h b/src/libs/sqlite/sqlitevalue.h
index 2ad97d7613..d4a461c34f 100644
--- a/src/libs/sqlite/sqlitevalue.h
+++ b/src/libs/sqlite/sqlitevalue.h
@@ -29,11 +29,11 @@
 #include "sqliteexception.h"
 
 #include <utils/smallstring.h>
-#include <utils/variant.h>
 
 #include <QVariant>
 
 #include <cstddef>
+#include <variant>
 
 namespace Sqlite {
 
@@ -48,7 +48,7 @@ template<typename StringType, typename BlobType>
 class ValueBase
 {
 public:
-    using VariantType = Utils::variant<NullValue, long long, double, StringType, BlobType>;
+    using VariantType = std::variant<NullValue, long long, double, StringType, BlobType>;
 
     ValueBase() = default;
 
@@ -104,18 +104,18 @@ public:
 
     bool isNull() const { return value.index() == 0; }
 
-    long long toInteger() const { return Utils::get<int(ValueType::Integer)>(value); }
+    long long toInteger() const { return std::get<int(ValueType::Integer)>(value); }
 
-    double toFloat() const { return Utils::get<int(ValueType::Float)>(value); }
+    double toFloat() const { return std::get<int(ValueType::Float)>(value); }
 
     Utils::SmallStringView toStringView() const
     {
-        return Utils::get<int(ValueType::String)>(value);
+        return std::get<int(ValueType::String)>(value);
     }
 
     BlobView toBlobView() const
     {
-        const BlobType &blob = Utils::get<int(ValueType::Blob)>(value);
+        const BlobType &blob = std::get<int(ValueType::Blob)>(value);
         if constexpr (std::is_same_v<BlobType, Blob>) {
             return {blob.bytes};
         } else {
@@ -146,7 +146,7 @@ public:
 
     friend bool operator==(const ValueBase &first, long long second)
     {
-        auto maybeInteger = Utils::get_if<int(ValueType::Integer)>(&first.value);
+        auto maybeInteger = std::get_if<int(ValueType::Integer)>(&first.value);
 
         return maybeInteger && *maybeInteger == second;
     }
@@ -155,7 +155,7 @@ public:
 
     friend bool operator==(const ValueBase &first, double second)
     {
-        auto maybeFloat = Utils::get_if<int(ValueType::Float)>(&first.value);
+        auto maybeFloat = std::get_if<int(ValueType::Float)>(&first.value);
 
         return maybeFloat && *maybeFloat == second;
     }
@@ -178,7 +178,7 @@ public:
 
     friend bool operator==(const ValueBase &first, Utils::SmallStringView second)
     {
-        auto maybeString = Utils::get_if<int(ValueType::String)>(&first.value);
+        auto maybeString = std::get_if<int(ValueType::String)>(&first.value);
 
         return maybeString && *maybeString == second;
     }
@@ -190,7 +190,7 @@ public:
 
     friend bool operator==(const ValueBase &first, const QString &second)
     {
-        auto maybeString = Utils::get_if<int(ValueType::String)>(&first.value);
+        auto maybeString = std::get_if<int(ValueType::String)>(&first.value);
 
         return maybeString && second == QLatin1String{maybeString->data(), int(maybeString->size())};
     }
@@ -219,7 +219,7 @@ public:
 
     friend bool operator==(const ValueBase &first, BlobView second)
     {
-        auto maybeBlob = Utils::get_if<int(ValueType::Blob)>(&first.value);
+        auto maybeBlob = std::get_if<int(ValueType::Blob)>(&first.value);
 
         return maybeBlob && *maybeBlob == second;
     }
diff --git a/src/libs/sqlite/tableconstraints.h b/src/libs/sqlite/tableconstraints.h
index b2dee2c928..8ff6e3419d 100644
--- a/src/libs/sqlite/tableconstraints.h
+++ b/src/libs/sqlite/tableconstraints.h
@@ -29,7 +29,8 @@
 
 #include <sqlitevalue.h>
 #include <utils/smallstringvector.h>
-#include <utils/variant.h>
+
+#include <variant>
 
 namespace Sqlite {
 class TablePrimaryKey
@@ -43,7 +44,7 @@ public:
     Utils::SmallStringVector columns;
 };
 
-using TableConstraint = Utils::variant<TablePrimaryKey>;
+using TableConstraint = std::variant<TablePrimaryKey>;
 using TableConstraints = std::vector<TableConstraint>;
 
 } // namespace Sqlite
diff --git a/src/libs/utils/CMakeLists.txt b/src/libs/utils/CMakeLists.txt
index 30ed664789..fa1d361174 100644
--- a/src/libs/utils/CMakeLists.txt
+++ b/src/libs/utils/CMakeLists.txt
@@ -5,7 +5,6 @@ add_qtc_library(Utils
     Qt6Core5Compat
   SOURCES
     ../3rdparty/optional/optional.hpp
-    ../3rdparty/variant/variant.hpp
     ../3rdparty/span/span.hpp
     QtConcurrentTools
     algorithm.h
@@ -182,7 +181,6 @@ add_qtc_library(Utils
     utils_global.h
     utilsicons.cpp utilsicons.h
     variablechooser.cpp variablechooser.h
-    variant.h
     winutils.cpp winutils.h
     wizard.cpp wizard.h
     wizardpage.cpp wizardpage.h
diff --git a/src/libs/utils/fsengine/fileiconprovider.cpp b/src/libs/utils/fsengine/fileiconprovider.cpp
index 0addee5386..d292684d32 100644
--- a/src/libs/utils/fsengine/fileiconprovider.cpp
+++ b/src/libs/utils/fsengine/fileiconprovider.cpp
@@ -30,7 +30,6 @@
 #include <utils/mimeutils.h>
 #include <utils/optional.h>
 #include <utils/qtcassert.h>
-#include <utils/variant.h>
 
 #include <QApplication>
 #include <QStyle>
@@ -43,6 +42,8 @@
 #include <QIcon>
 #include <QLoggingCategory>
 
+#include <variant>
+
 using namespace Utils;
 
 Q_LOGGING_CATEGORY(fileIconProvider, "qtc.core.fileiconprovider", QtWarningMsg)
@@ -65,7 +66,7 @@ Q_LOGGING_CATEGORY(fileIconProvider, "qtc.core.fileiconprovider", QtWarningMsg)
   retrieve icons via the icon() function.
   */
 
-using Item = Utils::variant<QIcon, QString>; // icon or filename for the icon
+using Item = std::variant<QIcon, QString>; // icon or filename for the icon
 
 namespace Utils {
 namespace FileIconProvider {
@@ -75,10 +76,10 @@ static Utils::optional<QIcon> getIcon(QHash<QString, Item> &cache, const QString
     auto it = cache.constFind(key);
     if (it == cache.constEnd())
         return {};
-    if (const QIcon *icon = Utils::get_if<QIcon>(&*it))
+    if (const QIcon *icon = std::get_if<QIcon>(&*it))
         return *icon;
     // need to create icon from file name first
-    const QString *fileName = Utils::get_if<QString>(&*it);
+    const QString *fileName = std::get_if<QString>(&*it);
     QTC_ASSERT(fileName, return {});
     const QIcon icon = QIcon(
         FileIconProvider::overlayIcon(QStyle::SP_FileIcon, QIcon(*fileName), QSize(16, 16)));
diff --git a/src/libs/utils/utils.qbs b/src/libs/utils/utils.qbs
index 4252ebae13..fba84763a5 100644
--- a/src/libs/utils/utils.qbs
+++ b/src/libs/utils/utils.qbs
@@ -327,8 +327,6 @@ Project {
             "utilsicons.cpp",
             "variablechooser.cpp",
             "variablechooser.h",
-            "variant.h",
-            "../3rdparty/variant/variant.hpp",
             "winutils.cpp",
             "winutils.h",
             "wizard.cpp",
diff --git a/src/libs/utils/variant.h b/src/libs/utils/variant.h
deleted file mode 100644
index 2f118e6b4c..0000000000
--- a/src/libs/utils/variant.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2017 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of Qt Creator.
-**
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-****************************************************************************/
-
-#pragma once
-
-/*
-    See std(::experimental)::variant.
-*/
-
-// std::variant from Apple's Clang supports methods that throw std::bad_optional_access only
-// with deployment target >= macOS 10.14
-// TODO: Use std::variant everywhere when we can require macOS 10.14
-#if !defined(__apple_build_version__)
-#include <variant>
-
-namespace Utils {
-using std::get;
-using std::get_if;
-using std::holds_alternative;
-using std::monostate;
-using std::variant;
-using std::variant_alternative_t;
-using std::visit;
-} // namespace Utils
-
-#else
-#include <3rdparty/variant/variant.hpp>
-
-namespace Utils {
-using mpark::get;
-using mpark::get_if;
-using mpark::holds_alternative;
-using mpark::monostate;
-using mpark::variant;
-using mpark::variant_alternative_t;
-using mpark::visit;
-} // namespace Utils
-
-#endif
diff --git a/src/plugins/android/avdmanageroutputparser.cpp b/src/plugins/android/avdmanageroutputparser.cpp
index 4965214334..c78b83a00f 100644
--- a/src/plugins/android/avdmanageroutputparser.cpp
+++ b/src/plugins/android/avdmanageroutputparser.cpp
@@ -30,12 +30,13 @@
 #include <utils/fileutils.h>
 #include <utils/optional.h>
 #include <utils/qtcassert.h>
-#include <utils/variant.h>
 
 #include <QLoggingCategory>
 #include <QRegularExpression>
 #include <QSettings>
 
+#include <variant>
+
 namespace {
 Q_LOGGING_CATEGORY(avdOutputParserLog, "qtc.android.avdOutputParser", QtWarningMsg)
 }
@@ -113,7 +114,7 @@ AndroidDeviceInfoList parseAvdList(const QString &output, QStringList *avdErrorP
     AndroidDeviceInfoList avdList;
     QStringList avdInfo;
     using ErrorPath = QString;
-    using AvdResult = Utils::variant<std::monostate, AndroidDeviceInfo, ErrorPath>;
+    using AvdResult = std::variant<std::monostate, AndroidDeviceInfo, ErrorPath>;
     const auto parseAvdInfo = [](const QStringList &avdInfo) {
         if (!avdInfo.filter(avdManufacturerError).isEmpty()) {
             for (const QString &line : avdInfo) {
@@ -138,9 +139,9 @@ AndroidDeviceInfoList parseAvdList(const QString &output, QStringList *avdErrorP
     for (const QString &line : lines) {
         if (line.startsWith("---------") || line.isEmpty()) {
             const AvdResult result = parseAvdInfo(avdInfo);
-            if (auto info = Utils::get_if<AndroidDeviceInfo>(&result))
+            if (auto info = std::get_if<AndroidDeviceInfo>(&result))
                 avdList << *info;
-            else if (auto errorPath = Utils::get_if<ErrorPath>(&result))
+            else if (auto errorPath = std::get_if<ErrorPath>(&result))
                 *avdErrorPaths << *errorPath;
             avdInfo.clear();
         } else {
diff --git a/src/plugins/clangcodemodel/clangdclient.cpp b/src/plugins/clangcodemodel/clangdclient.cpp
index 2e308d66a5..b750c59f08 100644
--- a/src/plugins/clangcodemodel/clangdclient.cpp
+++ b/src/plugins/clangcodemodel/clangdclient.cpp
@@ -411,7 +411,7 @@ ClangdClient::ClangdClient(Project *project, const Utils::FilePath &jsonDbDir)
 
     connect(this, &Client::workDone, this,
             [this, p = QPointer(project)](const ProgressToken &token) {
-        const QString * const val = Utils::get_if<QString>(&token);
+        const QString * const val = std::get_if<QString>(&token);
         if (val && *val == indexingToken()) {
             d->isFullyIndexed = true;
             emit indexingFinished();
@@ -511,7 +511,7 @@ void ClangdClient::handleDiagnostics(const PublishDiagnosticsParams &params)
             // We know that there's only one kind of diagnostic for which clangd has
             // a quickfix tweak, so let's not be wasteful.
             const Diagnostic::Code code = diagnostic.code().value_or(Diagnostic::Code());
-            const QString * const codeString = Utils::get_if<QString>(&code);
+            const QString * const codeString = std::get_if<QString>(&code);
             if (codeString && *codeString == "-Wswitch")
                 requestCodeActions(uri, diagnostic);
         }
@@ -577,7 +577,7 @@ class ClangdDiagnosticManager : public LanguageClient::DiagnosticManager
     {
         return Utils::filtered(diagnostics, [](const Diagnostic &diag){
             const Diagnostic::Code code = diag.code().value_or(Diagnostic::Code());
-            const QString * const codeString = Utils::get_if<QString>(&code);
+            const QString * const codeString = std::get_if<QString>(&code);
             return !codeString || *codeString != "drv_unknown_argument";
         });
     }
@@ -809,7 +809,7 @@ MessageId ClangdClient::requestSymbolInfo(const Utils::FilePath &filePath, const
         // According to the documentation, we should receive a single
         // object here, but it's a list. No idea what it means if there's
         // more than one entry. We choose the first one.
-        const auto list = Utils::get_if<QList<SymbolDetails>>(&result.value());
+        const auto list = std::get_if<QList<SymbolDetails>>(&result.value());
         if (!list || list->isEmpty()) {
             handler({}, {}, reqId);
             return;
@@ -922,9 +922,9 @@ void ClangdClient::gatherHelpItemForTooltip(const HoverRequest::Response &hoverR
                                             const DocumentUri &uri)
 {
     if (const Utils::optional<HoverResult> result = hoverResponse.result()) {
-        if (auto hover = Utils::get_if<Hover>(&(*result))) {
+        if (auto hover = std::get_if<Hover>(&(*result))) {
             const HoverContent content = hover->content();
-            const MarkupContent *const markup = Utils::get_if<MarkupContent>(&content);
+            const MarkupContent *const markup = std::get_if<MarkupContent>(&content);
             if (markup) {
                 const QString markupString = markup->content();
 
@@ -964,7 +964,7 @@ void ClangdClient::gatherHelpItemForTooltip(const HoverRequest::Response &hoverR
         const MessageId id = hoverResponse.id();
         Range range;
         if (const Utils::optional<HoverResult> result = hoverResponse.result()) {
-            if (auto hover = Utils::get_if<Hover>(&(*result)))
+            if (auto hover = std::get_if<Hover>(&(*result)))
                 range = hover->range().value_or(Range());
         }
         const ClangdAstPath path = getAstPath(ast, range);
@@ -1340,10 +1340,10 @@ MessageId ClangdClient::Private::getAndHandleAst(const TextDocOrFile &doc,
                                                  const AstHandler &astHandler,
                                                  AstCallbackMode callbackMode, const Range &range)
 {
-    const auto textDocPtr = Utils::get_if<const TextDocument *>(&doc);
+    const auto textDocPtr = std::get_if<const TextDocument *>(&doc);
     const TextDocument * const textDoc = textDocPtr ? *textDocPtr : nullptr;
     const Utils::FilePath filePath = textDoc ? textDoc->filePath()
-                                             : Utils::get<Utils::FilePath>(doc);
+                                             : std::get<Utils::FilePath>(doc);
 
     // If the entire AST is requested and the document's AST is in the cache and it is up to date,
     // call the handler.
diff --git a/src/plugins/clangcodemodel/clangdclient.h b/src/plugins/clangcodemodel/clangdclient.h
index 9c7ec12e03..7476ceff05 100644
--- a/src/plugins/clangcodemodel/clangdclient.h
+++ b/src/plugins/clangcodemodel/clangdclient.h
@@ -110,7 +110,7 @@ public:
     Utils::optional<bool> hasVirtualFunctionAt(TextEditor::TextDocument *doc, int revision,
                                                const LanguageServerProtocol::Range &range);
 
-    using TextDocOrFile = Utils::variant<const TextEditor::TextDocument *, Utils::FilePath>;
+    using TextDocOrFile = std::variant<const TextEditor::TextDocument *, Utils::FilePath>;
     using AstHandler = std::function<void(const ClangdAstNode &ast,
                                                 const LanguageServerProtocol::MessageId &)>;
     enum class AstCallbackMode { SyncIfPossible, AlwaysAsync };
diff --git a/src/plugins/clangcodemodel/clangdcompletion.cpp b/src/plugins/clangcodemodel/clangdcompletion.cpp
index e37cf293de..af48d3d6e3 100644
--- a/src/plugins/clangcodemodel/clangdcompletion.cpp
+++ b/src/plugins/clangcodemodel/clangdcompletion.cpp
@@ -362,10 +362,10 @@ ClangdCompletionItem::SpecialQtType ClangdCompletionItem::getQtType(const Comple
     if (!doc)
         return SpecialQtType::None;
     QString docText;
-    if (Utils::holds_alternative<QString>(*doc))
-        docText = Utils::get<QString>(*doc);
-    else if (Utils::holds_alternative<MarkupContent>(*doc))
-        docText = Utils::get<MarkupContent>(*doc).content();
+    if (std::holds_alternative<QString>(*doc))
+        docText = std::get<QString>(*doc);
+    else if (std::holds_alternative<MarkupContent>(*doc))
+        docText = std::get<MarkupContent>(*doc).content();
     if (docText.contains("Annotation: qt_signal"))
         return SpecialQtType::Signal;
     if (docText.contains("Annotation: qt_slot"))
diff --git a/src/plugins/clangcodemodel/clangdfollowsymbol.cpp b/src/plugins/clangcodemodel/clangdfollowsymbol.cpp
index a0e6aae610..0ff6ac1f7a 100644
--- a/src/plugins/clangcodemodel/clangdfollowsymbol.cpp
+++ b/src/plugins/clangcodemodel/clangdfollowsymbol.cpp
@@ -399,9 +399,9 @@ void ClangdFollowSymbol::Private::handleGotoImplementationResult(
 {
     if (const optional<GotoResult> &result = response.result()) {
         QList<Link> newLinks;
-        if (const auto ploc = get_if<Location>(&*result))
+        if (const auto ploc = std::get_if<Location>(&*result))
             newLinks = {ploc->toLink()};
-        if (const auto plloc = get_if<QList<Location>>(&*result))
+        if (const auto plloc = std::get_if<QList<Location>>(&*result))
             newLinks = transform(*plloc, &Location::toLink);
         for (const Link &link : qAsConst(newLinks)) {
             if (!allLinks.contains(link)) {
@@ -475,9 +475,9 @@ void ClangdFollowSymbol::Private::handleGotoImplementationResult(
             Link newLink;
             if (optional<GotoResult> _result = response.result()) {
                 const GotoResult result = _result.value();
-                if (const auto ploc = get_if<Location>(&result)) {
+                if (const auto ploc = std::get_if<Location>(&result)) {
                     newLink = ploc->toLink();
-                } else if (const auto plloc = get_if<QList<Location>>(&result)) {
+                } else if (const auto plloc = std::get_if<QList<Location>>(&result)) {
                     if (!plloc->isEmpty())
                         newLink = plloc->value(0).toLink();
                 }
diff --git a/src/plugins/clangcodemodel/clangdquickfixes.cpp b/src/plugins/clangcodemodel/clangdquickfixes.cpp
index b0dfded775..c56e37e956 100644
--- a/src/plugins/clangcodemodel/clangdquickfixes.cpp
+++ b/src/plugins/clangcodemodel/clangdquickfixes.cpp
@@ -85,20 +85,20 @@ private:
     TextEditor::GenericProposal *handleCodeActionResult(const CodeActionResult &result) override
     {
         auto toOperation =
-            [=](const Utils::variant<Command, CodeAction> &item) -> QuickFixOperation * {
-            if (auto action = Utils::get_if<CodeAction>(&item)) {
+            [=](const std::variant<Command, CodeAction> &item) -> QuickFixOperation * {
+            if (auto action = std::get_if<CodeAction>(&item)) {
                 const Utils::optional<QList<Diagnostic>> diagnostics = action->diagnostics();
                 if (!diagnostics.has_value() || diagnostics->isEmpty())
                     return new CodeActionQuickFixOperation(*action, client());
             }
-            if (auto command = Utils::get_if<Command>(&item))
+            if (auto command = std::get_if<Command>(&item))
                 return new CommandQuickFixOperation(*command, client());
             return nullptr;
         };
 
-        if (auto list = Utils::get_if<QList<Utils::variant<Command, CodeAction>>>(&result)) {
+        if (auto list = std::get_if<QList<std::variant<Command, CodeAction>>>(&result)) {
             QuickFixOperations ops;
-            for (const Utils::variant<Command, CodeAction> &item : *list) {
+            for (const std::variant<Command, CodeAction> &item : *list) {
                 if (QuickFixOperation *op = toOperation(item)) {
                     op->setDescription("clangd: " + op->description());
                     ops << op;
diff --git a/src/plugins/clangcodemodel/clangdswitchdecldef.cpp b/src/plugins/clangcodemodel/clangdswitchdecldef.cpp
index 28c27034f4..125714bdb1 100644
--- a/src/plugins/clangcodemodel/clangdswitchdecldef.cpp
+++ b/src/plugins/clangcodemodel/clangdswitchdecldef.cpp
@@ -152,7 +152,7 @@ QTextCursor ClangdSwitchDeclDef::Private::cursorForFunctionName(const ClangdAstN
 {
     QTC_ASSERT(docSymbols, return {});
 
-    const auto symbolList = Utils::get_if<QList<DocumentSymbol>>(&*docSymbols);
+    const auto symbolList = std::get_if<QList<DocumentSymbol>>(&*docSymbols);
     if (!symbolList)
         return {};
     const Range &astRange = functionNode.range();
diff --git a/src/plugins/clangcodemodel/clangtextmark.cpp b/src/plugins/clangcodemodel/clangtextmark.cpp
index 4fb31804fe..ce206f672c 100644
--- a/src/plugins/clangcodemodel/clangtextmark.cpp
+++ b/src/plugins/clangcodemodel/clangtextmark.cpp
@@ -233,7 +233,7 @@ ClangDiagnostic convertDiagnostic(const ClangdDiagnostic &src, const FilePath &f
     if (src.severity())
         target.severity = convertSeverity(*src.severity());
     const Diagnostic::Code code = src.code().value_or(Diagnostic::Code());
-    const QString * const codeString = Utils::get_if<QString>(&code);
+    const QString * const codeString = std::get_if<QString>(&code);
     if (codeString && codeString->startsWith("-W"))
         target.enableOption = *codeString;
     for (const CodeAction &codeAction : src.codeActions().value_or(QList<CodeAction>())) {
diff --git a/src/plugins/clangcodemodel/test/clangdtests.cpp b/src/plugins/clangcodemodel/test/clangdtests.cpp
index df9dc9ea5b..084e203f41 100644
--- a/src/plugins/clangcodemodel/test/clangdtests.cpp
+++ b/src/plugins/clangcodemodel/test/clangdtests.cpp
@@ -1464,7 +1464,7 @@ public:
     void insertCodeSnippet(int pos, const QString &text, const SnippetParser &parser) override
     {
         const auto parseResult = parser(text);
-        if (const auto snippet = Utils::get_if<ParsedSnippet>(&parseResult)) {
+        if (const auto snippet = std::get_if<ParsedSnippet>(&parseResult)) {
             if (!snippet->parts.isEmpty())
                 textCursorAt(pos).insertText(snippet->parts.first().text);
         }
diff --git a/src/plugins/clangtools/clangtool.cpp b/src/plugins/clangtools/clangtool.cpp
index c7c3f4a0dd..7a642dc5ef 100644
--- a/src/plugins/clangtools/clangtool.cpp
+++ b/src/plugins/clangtools/clangtool.cpp
@@ -680,8 +680,8 @@ void ClangTool::startTool(ClangTool::FileSelection fileSelection,
     connect(m_runControl, &RunControl::stopped, this, &ClangTool::onRunControlStopped);
 
     // Run worker
-    const bool preventBuild = holds_alternative<FilePath>(fileSelection)
-                              || get<FileSelectionType>(fileSelection)
+    const bool preventBuild = std::holds_alternative<FilePath>(fileSelection)
+                              || std::get<FileSelectionType>(fileSelection)
                                      == FileSelectionType::CurrentFile;
     const bool buildBeforeAnalysis = !preventBuild && runSettings.buildBeforeAnalysis();
     m_runWorker = new ClangToolRunWorker(m_runControl,
@@ -730,7 +730,7 @@ Diagnostics ClangTool::read(OutputFileFormat outputFileFormat,
 
 FileInfos ClangTool::collectFileInfos(Project *project, FileSelection fileSelection)
 {
-    FileSelectionType *selectionType = get_if<FileSelectionType>(&fileSelection);
+    FileSelectionType *selectionType = std::get_if<FileSelectionType>(&fileSelection);
     // early bailout
     if (selectionType && *selectionType == FileSelectionType::CurrentFile
         && !EditorManager::currentDocument()) {
@@ -759,8 +759,8 @@ FileInfos ClangTool::collectFileInfos(Project *project, FileSelection fileSelect
         return dialog.fileInfos();
     }
 
-    const FilePath filePath = holds_alternative<FilePath>(fileSelection)
-                                  ? get<FilePath>(fileSelection)
+    const FilePath filePath = std::holds_alternative<FilePath>(fileSelection)
+                                  ? std::get<FilePath>(fileSelection)
                                   : EditorManager::currentDocument()->filePath(); // see early bailout
     if (!filePath.isEmpty()) {
         const FileInfo fileInfo = Utils::findOrDefault(allFileInfos, [&](const FileInfo &fi) {
diff --git a/src/plugins/clangtools/clangtool.h b/src/plugins/clangtools/clangtool.h
index d0f993b1a0..59f78354fa 100644
--- a/src/plugins/clangtools/clangtool.h
+++ b/src/plugins/clangtools/clangtool.h
@@ -35,7 +35,7 @@
 #include <projectexplorer/runconfiguration.h>
 #include <cppeditor/projectinfo.h>
 
-#include <utils/variant.h>
+#include <variant>
 
 QT_BEGIN_NAMESPACE
 class QFrame;
@@ -87,7 +87,7 @@ public:
         AskUser,
     };
 
-    using FileSelection = Utils::variant<FileSelectionType, Utils::FilePath>;
+    using FileSelection = std::variant<FileSelectionType, Utils::FilePath>;
 
     void startTool(FileSelection fileSelection);
     void startTool(FileSelection fileSelection,
diff --git a/src/plugins/languageclient/client.cpp b/src/plugins/languageclient/client.cpp
index d4c79d833e..425eee223b 100644
--- a/src/plugins/languageclient/client.cpp
+++ b/src/plugins/languageclient/client.cpp
@@ -623,7 +623,7 @@ void Client::openDocument(TextEditor::TextDocument *document)
         }
     } else if (Utils::optional<ServerCapabilities::TextDocumentSync> _sync
                = d->m_serverCapabilities.textDocumentSync()) {
-        if (auto options = Utils::get_if<TextDocumentSyncOptions>(&*_sync)) {
+        if (auto options = std::get_if<TextDocumentSyncOptions>(&*_sync)) {
             if (!options->openClose().value_or(true))
                 return;
         }
@@ -791,11 +791,11 @@ void ClientPrivate::requestDocumentHighlightsNow(TextEditor::TextEditorWidget *w
         if (!option.filterApplies(widget->textDocument()->filePath()))
             return;
     } else {
-        Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>> provider
+        Utils::optional<std::variant<bool, WorkDoneProgressOptions>> provider
             = m_serverCapabilities.documentHighlightProvider();
         if (!provider.has_value())
             return;
-        if (Utils::holds_alternative<bool>(*provider) && !Utils::get<bool>(*provider))
+        if (std::holds_alternative<bool>(*provider) && !std::get<bool>(*provider))
             return;
     }
 
@@ -819,7 +819,7 @@ void ClientPrivate::requestDocumentHighlightsNow(TextEditor::TextEditorWidget *w
             const Id &id = TextEditor::TextEditorWidget::CodeSemanticsSelection;
             QList<QTextEdit::ExtraSelection> selections;
             const Utils::optional<DocumentHighlightsResult> &result = response.result();
-            if (!result.has_value() || holds_alternative<std::nullptr_t>(*result)) {
+            if (!result.has_value() || std::holds_alternative<std::nullptr_t>(*result)) {
                 widget->setExtraSelections(id, selections);
                 return;
             }
@@ -827,7 +827,7 @@ void ClientPrivate::requestDocumentHighlightsNow(TextEditor::TextEditorWidget *w
             const QTextCharFormat &format =
                 widget->textDocument()->fontSettings().toTextCharFormat(TextEditor::C_OCCURRENCES);
             QTextDocument *document = widget->document();
-            for (const auto &highlight : get<QList<DocumentHighlight>>(*result)) {
+            for (const auto &highlight : std::get<QList<DocumentHighlight>>(*result)) {
                 QTextEdit::ExtraSelection selection{widget->textCursor(), format};
                 const int &start = highlight.range().start().toPositionInDocument(document);
                 const int &end = highlight.range().end().toPositionInDocument(document);
@@ -1013,7 +1013,7 @@ void Client::documentContentsSaved(TextEditor::TextDocument *document)
         }
     } else if (Utils::optional<ServerCapabilities::TextDocumentSync> _sync
                = d->m_serverCapabilities.textDocumentSync()) {
-        if (auto options = Utils::get_if<TextDocumentSyncOptions>(&*_sync)) {
+        if (auto options = std::get_if<TextDocumentSyncOptions>(&*_sync)) {
             if (Utils::optional<SaveOptions> saveOptions = options->save())
                 includeText = saveOptions->includeText().value_or(includeText);
         }
@@ -1047,7 +1047,7 @@ void Client::documentWillSave(Core::IDocument *document)
         }
     } else if (Utils::optional<ServerCapabilities::TextDocumentSync> _sync
                = d->m_serverCapabilities.textDocumentSync()) {
-        if (auto options = Utils::get_if<TextDocumentSyncOptions>(&*_sync))
+        if (auto options = std::get_if<TextDocumentSyncOptions>(&*_sync))
             send = options->willSave().value_or(send);
     }
     if (!send)
@@ -1285,9 +1285,9 @@ void Client::requestCodeActions(const CodeActionRequest &request)
         if (option.isValid() && !option.filterApplies(fileName))
             return;
     } else {
-        Utils::variant<bool, CodeActionOptions> provider
+        std::variant<bool, CodeActionOptions> provider
             = d->m_serverCapabilities.codeActionProvider().value_or(false);
-        if (!(Utils::holds_alternative<CodeActionOptions>(provider) || Utils::get<bool>(provider)))
+        if (!(std::holds_alternative<CodeActionOptions>(provider) || std::get<bool>(provider)))
             return;
     }
 
@@ -1300,12 +1300,12 @@ void Client::handleCodeActionResponse(const CodeActionRequest::Response &respons
     if (const Utils::optional<CodeActionRequest::Response::Error> &error = response.error())
         log(*error);
     if (const Utils::optional<CodeActionResult> &result = response.result()) {
-        if (auto list = Utils::get_if<QList<Utils::variant<Command, CodeAction>>>(&*result)) {
+        if (auto list = std::get_if<QList<std::variant<Command, CodeAction>>>(&*result)) {
             QList<CodeAction> codeActions;
-            for (const Utils::variant<Command, CodeAction> &item : *list) {
-                if (auto action = Utils::get_if<CodeAction>(&item))
+            for (const std::variant<Command, CodeAction> &item : *list) {
+                if (auto action = std::get_if<CodeAction>(&item))
                     codeActions << *action;
-                else if (auto command = Utils::get_if<Command>(&item))
+                else if (auto command = std::get_if<Command>(&item))
                     Q_UNUSED(command) // todo
             }
             updateCodeActionRefactoringMarker(this, codeActions, uri);
@@ -1506,12 +1506,12 @@ bool Client::supportsDocumentSymbols(const TextEditor::TextDocument *doc) const
         return !options.isValid()
                || options.filterApplies(doc->filePath(), Utils::mimeTypeForName(doc->mimeType()));
     }
-    const Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>> &provider
+    const Utils::optional<std::variant<bool, WorkDoneProgressOptions>> &provider
         = capabilities().documentSymbolProvider();
     if (!provider.has_value())
         return false;
-    if (Utils::holds_alternative<bool>(*provider))
-        return Utils::get<bool>(*provider);
+    if (std::holds_alternative<bool>(*provider))
+        return std::get<bool>(*provider);
     return true;
 }
 
@@ -1998,11 +1998,11 @@ void ClientPrivate::initializeCallback(const InitializeRequest::Response &initRe
     qCDebug(LOGLSPCLIENT) << "language server " << m_displayName << " initialized";
     m_state = Client::Initialized;
     q->sendMessage(InitializeNotification(InitializedParams()));
-    Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>> documentSymbolProvider
+    Utils::optional<std::variant<bool, WorkDoneProgressOptions>> documentSymbolProvider
         = q->capabilities().documentSymbolProvider();
     if (documentSymbolProvider.has_value()) {
-        if (!Utils::holds_alternative<bool>(*documentSymbolProvider)
-            || Utils::get<bool>(*documentSymbolProvider)) {
+        if (!std::holds_alternative<bool>(*documentSymbolProvider)
+            || std::get<bool>(*documentSymbolProvider)) {
             TextEditor::IOutlineWidgetFactory::updateOutline();
         }
     }
@@ -2044,8 +2044,9 @@ bool ClientPrivate::sendWorkspceFolderChanges() const
             if (folder->supported().value_or(false)) {
                 // holds either the Id for deregistration or whether it is registered
                 auto notification = folder->changeNotifications().value_or(false);
-                return holds_alternative<QString>(notification)
-                        || (holds_alternative<bool>(notification) && get<bool>(notification));
+                return std::holds_alternative<QString>(notification)
+                       || (std::holds_alternative<bool>(notification)
+                           && std::get<bool>(notification));
             }
         }
     }
diff --git a/src/plugins/languageclient/languageclientcompletionassist.cpp b/src/plugins/languageclient/languageclientcompletionassist.cpp
index 8066e9b752..0d6bd81ca2 100644
--- a/src/plugins/languageclient/languageclientcompletionassist.cpp
+++ b/src/plugins/languageclient/languageclientcompletionassist.cpp
@@ -144,11 +144,11 @@ QString LanguageClientCompletionItem::detail() const
     if (auto _doc = m_item.documentation()) {
         auto doc = *_doc;
         QString detailDocText;
-        if (Utils::holds_alternative<QString>(doc)) {
-            detailDocText = Utils::get<QString>(doc);
-        } else if (Utils::holds_alternative<MarkupContent>(doc)) {
+        if (std::holds_alternative<QString>(doc)) {
+            detailDocText = std::get<QString>(doc);
+        } else if (std::holds_alternative<MarkupContent>(doc)) {
             // TODO markdown parser?
-            detailDocText = Utils::get<MarkupContent>(doc).content();
+            detailDocText = std::get<MarkupContent>(doc).content();
         }
         if (!detailDocText.isEmpty())
             return detailDocText;
@@ -425,18 +425,18 @@ void LanguageClientCompletionAssistProcessor::handleCompletionResponse(
         m_client->log(*error);
 
     const Utils::optional<CompletionResult> &result = response.result();
-    if (!result || Utils::holds_alternative<std::nullptr_t>(*result)) {
+    if (!result || std::holds_alternative<std::nullptr_t>(*result)) {
         setAsyncProposalAvailable(nullptr);
         m_client->removeAssistProcessor(this);
         return;
     }
 
     QList<CompletionItem> items;
-    if (Utils::holds_alternative<CompletionList>(*result)) {
-        const auto &list = Utils::get<CompletionList>(*result);
+    if (std::holds_alternative<CompletionList>(*result)) {
+        const auto &list = std::get<CompletionList>(*result);
         items = list.items().value_or(QList<CompletionItem>());
-    } else if (Utils::holds_alternative<QList<CompletionItem>>(*result)) {
-        items = Utils::get<QList<CompletionItem>>(*result);
+    } else if (std::holds_alternative<QList<CompletionItem>>(*result)) {
+        items = std::get<QList<CompletionItem>>(*result);
     }
     auto proposalItems = generateCompletionItems(items);
     if (!m_snippetsGroup.isEmpty()) {
diff --git a/src/plugins/languageclient/languageclientformatter.cpp b/src/plugins/languageclient/languageclientformatter.cpp
index f1cea20b93..f6b811f917 100644
--- a/src/plugins/languageclient/languageclientformatter.cpp
+++ b/src/plugins/languageclient/languageclientformatter.cpp
@@ -86,11 +86,11 @@ QFutureWatcher<ChangeSet> *LanguageClientFormatter::format(
             return nullptr;
         }
     } else {
-        const Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>> &provider
+        const Utils::optional<std::variant<bool, WorkDoneProgressOptions>> &provider
             = m_client->capabilities().documentRangeFormattingProvider();
         if (!provider.has_value())
             return nullptr;
-        if (Utils::holds_alternative<bool>(*provider) && !Utils::get<bool>(*provider))
+        if (std::holds_alternative<bool>(*provider) && !std::get<bool>(*provider))
             return nullptr;
     }
     DocumentRangeFormattingParams params;
diff --git a/src/plugins/languageclient/languageclienthoverhandler.cpp b/src/plugins/languageclient/languageclienthoverhandler.cpp
index 32db0e5319..e37c0a38aa 100644
--- a/src/plugins/languageclient/languageclienthoverhandler.cpp
+++ b/src/plugins/languageclient/languageclienthoverhandler.cpp
@@ -66,7 +66,7 @@ void HoverHandler::setHelpItem(const LanguageServerProtocol::MessageId &msgId,
 {
     if (msgId == m_response.id()) {
         if (Utils::optional<HoverResult> result = m_response.result()) {
-            if (auto hover = Utils::get_if<Hover>(&(*result)))
+            if (auto hover = std::get_if<Hover>(&(*result)))
                 setContent(hover->content());
         }
         m_response = {};
@@ -107,11 +107,11 @@ void HoverHandler::identifyMatch(TextEditor::TextEditorWidget *editorWidget,
     if (m_preferDiagnostics && reportDiagnostics(cursor))
         return;
 
-    const Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>> &provider
+    const Utils::optional<std::variant<bool, WorkDoneProgressOptions>> &provider
         = m_client->capabilities().hoverProvider();
     bool sendMessage = provider.has_value();
-    if (sendMessage && Utils::holds_alternative<bool>(*provider))
-        sendMessage = Utils::get<bool>(*provider);
+    if (sendMessage && std::holds_alternative<bool>(*provider))
+        sendMessage = std::get<bool>(*provider);
     if (Utils::optional<bool> registered = m_client->dynamicCapabilities().isRegistered(
             HoverRequest::methodName)) {
         sendMessage = *registered;
@@ -146,7 +146,7 @@ void HoverHandler::handleResponse(const HoverRequest::Response &response, const
             m_client->log(*error);
     }
     if (Utils::optional<HoverResult> result = response.result()) {
-        if (auto hover = Utils::get_if<Hover>(&(*result))) {
+        if (auto hover = std::get_if<Hover>(&(*result))) {
             if (m_helpItemProvider) {
                 m_response = response;
                 m_helpItemProvider(response, m_uri);
@@ -166,9 +166,9 @@ static QString toolTipForMarkedStrings(const QList<MarkedString> &markedStrings)
     for (const MarkedString &markedString : markedStrings) {
         if (!tooltip.isEmpty())
             tooltip += '\n';
-        if (auto string = Utils::get_if<QString>(&markedString))
+        if (auto string = std::get_if<QString>(&markedString))
             tooltip += *string;
-        else if (auto string = Utils::get_if<MarkedLanguageString>(&markedString))
+        else if (auto string = std::get_if<MarkedLanguageString>(&markedString))
             tooltip += string->value() + " [" + string->language() + ']';
     }
     return tooltip;
@@ -176,11 +176,11 @@ static QString toolTipForMarkedStrings(const QList<MarkedString> &markedStrings)
 
 void HoverHandler::setContent(const HoverContent &hoverContent)
 {
-    if (auto markupContent = Utils::get_if<MarkupContent>(&hoverContent))
+    if (auto markupContent = std::get_if<MarkupContent>(&hoverContent))
         setToolTip(markupContent->content(), markupContent->textFormat());
-    else if (auto markedString = Utils::get_if<MarkedString>(&hoverContent))
+    else if (auto markedString = std::get_if<MarkedString>(&hoverContent))
         setToolTip(toolTipForMarkedStrings({*markedString}));
-    else if (auto markedStrings = Utils::get_if<QList<MarkedString>>(&hoverContent))
+    else if (auto markedStrings = std::get_if<QList<MarkedString>>(&hoverContent))
         setToolTip(toolTipForMarkedStrings(*markedStrings));
 }
 
diff --git a/src/plugins/languageclient/languageclientoutline.cpp b/src/plugins/languageclient/languageclientoutline.cpp
index 6928edeccf..2a7d97f197 100644
--- a/src/plugins/languageclient/languageclientoutline.cpp
+++ b/src/plugins/languageclient/languageclientoutline.cpp
@@ -296,10 +296,10 @@ void LanguageClientOutlineWidget::handleResponse(const DocumentUri &uri,
 {
     if (uri != m_uri)
         return;
-    if (Utils::holds_alternative<QList<SymbolInformation>>(result))
-        m_model.setInfo(Utils::get<QList<SymbolInformation>>(result));
-    else if (Utils::holds_alternative<QList<DocumentSymbol>>(result))
-        m_model.setInfo(Utils::get<QList<DocumentSymbol>>(result));
+    if (std::holds_alternative<QList<SymbolInformation>>(result))
+        m_model.setInfo(std::get<QList<SymbolInformation>>(result));
+    else if (std::holds_alternative<QList<DocumentSymbol>>(result))
+        m_model.setInfo(std::get<QList<DocumentSymbol>>(result));
     else
         m_model.clear();
 
@@ -440,10 +440,10 @@ void OutlineComboBox::updateModel(const DocumentUri &resultUri, const DocumentSy
 {
     if (m_uri != resultUri)
         return;
-    if (Utils::holds_alternative<QList<SymbolInformation>>(result))
-        m_model.setInfo(Utils::get<QList<SymbolInformation>>(result));
-    else if (Utils::holds_alternative<QList<DocumentSymbol>>(result))
-        m_model.setInfo(Utils::get<QList<DocumentSymbol>>(result));
+    if (std::holds_alternative<QList<SymbolInformation>>(result))
+        m_model.setInfo(std::get<QList<SymbolInformation>>(result));
+    else if (std::holds_alternative<QList<DocumentSymbol>>(result))
+        m_model.setInfo(std::get<QList<DocumentSymbol>>(result));
     else
         m_model.clear();
 
diff --git a/src/plugins/languageclient/languageclientquickfix.cpp b/src/plugins/languageclient/languageclientquickfix.cpp
index e65ba296b1..4a3c2d3d6b 100644
--- a/src/plugins/languageclient/languageclientquickfix.cpp
+++ b/src/plugins/languageclient/languageclientquickfix.cpp
@@ -124,12 +124,12 @@ void LanguageClientQuickFixAssistProcessor::handleCodeActionResponse(const CodeA
 
 GenericProposal *LanguageClientQuickFixAssistProcessor::handleCodeActionResult(const CodeActionResult &result)
 {
-    if (auto list = Utils::get_if<QList<Utils::variant<Command, CodeAction>>>(&result)) {
+    if (auto list = std::get_if<QList<std::variant<Command, CodeAction>>>(&result)) {
         QuickFixOperations ops;
-        for (const Utils::variant<Command, CodeAction> &item : *list) {
-            if (auto action = Utils::get_if<CodeAction>(&item))
+        for (const std::variant<Command, CodeAction> &item : *list) {
+            if (auto action = std::get_if<CodeAction>(&item))
                 ops << new CodeActionQuickFixOperation(*action, m_client);
-            else if (auto command = Utils::get_if<Command>(&item))
+            else if (auto command = std::get_if<Command>(&item))
                 ops << new CommandQuickFixOperation(*command, m_client);
         }
         return GenericProposal::createProposal(m_assistInterface.data(), ops);
diff --git a/src/plugins/languageclient/languageclientsymbolsupport.cpp b/src/plugins/languageclient/languageclientsymbolsupport.cpp
index 7e6dcdb6b2..7be82fb433 100644
--- a/src/plugins/languageclient/languageclientsymbolsupport.cpp
+++ b/src/plugins/languageclient/languageclientsymbolsupport.cpp
@@ -64,11 +64,11 @@ static void sendTextDocumentPositionParamsRequest(Client *client,
         else
             sendMessage = supportedFile;
     } else {
-        const Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>> &provider
+        const Utils::optional<std::variant<bool, WorkDoneProgressOptions>> &provider
             = serverCapability.referencesProvider();
         sendMessage = provider.has_value();
-        if (sendMessage && Utils::holds_alternative<bool>(*provider))
-            sendMessage = Utils::get<bool>(*provider);
+        if (sendMessage && std::holds_alternative<bool>(*provider))
+            sendMessage = std::get<bool>(*provider);
     }
     if (sendMessage)
         client->sendMessage(request);
@@ -79,11 +79,11 @@ static void handleGotoDefinitionResponse(const GotoDefinitionRequest::Response &
                                          Utils::optional<Utils::Link> linkUnderCursor)
 {
     if (Utils::optional<GotoResult> result = response.result()) {
-        if (Utils::holds_alternative<std::nullptr_t>(*result)) {
+        if (std::holds_alternative<std::nullptr_t>(*result)) {
             callback({});
-        } else if (auto ploc = Utils::get_if<Location>(&*result)) {
+        } else if (auto ploc = std::get_if<Location>(&*result)) {
             callback(linkUnderCursor.value_or(ploc->toLink()));
-        } else if (auto plloc = Utils::get_if<QList<Location>>(&*result)) {
+        } else if (auto plloc = std::get_if<QList<Location>>(&*result)) {
             if (!plloc->isEmpty())
                 callback(linkUnderCursor.value_or(plloc->value(0).toLink()));
             else
@@ -260,11 +260,11 @@ static bool supportsRename(Client *client,
         }
     }
     if (auto renameProvider = client->capabilities().renameProvider()) {
-        if (Utils::holds_alternative<bool>(*renameProvider)) {
-            if (!Utils::get<bool>(*renameProvider))
+        if (std::holds_alternative<bool>(*renameProvider)) {
+            if (!std::get<bool>(*renameProvider))
                 return false;
-        } else if (Utils::holds_alternative<ServerCapabilities::RenameOptions>(*renameProvider)) {
-            prepareSupported = Utils::get<ServerCapabilities::RenameOptions>(*renameProvider)
+        } else if (std::holds_alternative<ServerCapabilities::RenameOptions>(*renameProvider)) {
+            prepareSupported = std::get<ServerCapabilities::RenameOptions>(*renameProvider)
                                    .prepareProvider()
                                    .value_or(false);
         }
@@ -306,11 +306,11 @@ void SymbolSupport::requestPrepareRename(const TextDocumentPositionParams &param
 
         const Utils::optional<PrepareRenameResult> &result = response.result();
         if (result.has_value()) {
-            if (Utils::holds_alternative<PlaceHolderResult>(*result)) {
-                auto placeHolderResult = Utils::get<PlaceHolderResult>(*result);
+            if (std::holds_alternative<PlaceHolderResult>(*result)) {
+                auto placeHolderResult = std::get<PlaceHolderResult>(*result);
                 startRenameSymbol(params, placeHolderResult.placeHolder());
-            } else if (Utils::holds_alternative<Range>(*result)) {
-                auto range = Utils::get<Range>(*result);
+            } else if (std::holds_alternative<Range>(*result)) {
+                auto range = std::get<Range>(*result);
                 startRenameSymbol(params, placeholder);
             }
         }
diff --git a/src/plugins/languageclient/locatorfilter.cpp b/src/plugins/languageclient/locatorfilter.cpp
index 6dd843900d..fdde560674 100644
--- a/src/plugins/languageclient/locatorfilter.cpp
+++ b/src/plugins/languageclient/locatorfilter.cpp
@@ -211,9 +211,9 @@ QList<Core::LocatorFilterEntry> DocumentLocatorFilter::matchesFor(
 
     QTC_ASSERT(m_currentSymbols.has_value(), return {});
 
-    if (auto list = Utils::get_if<QList<DocumentSymbol>>(&*m_currentSymbols))
+    if (auto list = std::get_if<QList<DocumentSymbol>>(&*m_currentSymbols))
         return generateEntries(*list, entry);
-    else if (auto list = Utils::get_if<QList<SymbolInformation>>(&*m_currentSymbols))
+    else if (auto list = std::get_if<QList<SymbolInformation>>(&*m_currentSymbols))
         return generateEntries(*list, entry);
 
     return {};
@@ -277,11 +277,11 @@ void WorkspaceLocatorFilter::prepareSearch(const QString &entry,
             continue;
         if (!(force || client->locatorsEnabled()))
             continue;
-        Utils::optional<Utils::variant<bool, WorkDoneProgressOptions>> capability
+        Utils::optional<std::variant<bool, WorkDoneProgressOptions>> capability
             = client->capabilities().workspaceSymbolProvider();
         if (!capability.has_value())
             continue;
-        if (Utils::holds_alternative<bool>(*capability) && !Utils::get<bool>(*capability))
+        if (std::holds_alternative<bool>(*capability) && !std::get<bool>(*capability))
             continue;
         WorkspaceSymbolRequest request(params);
         request.setResponseCallback(
diff --git a/src/plugins/languageclient/progressmanager.cpp b/src/plugins/languageclient/progressmanager.cpp
index d25da8a3e0..4fe459bcec 100644
--- a/src/plugins/languageclient/progressmanager.cpp
+++ b/src/plugins/languageclient/progressmanager.cpp
@@ -45,11 +45,11 @@ void ProgressManager::handleProgress(const LanguageServerProtocol::ProgressParam
 {
     const ProgressToken &token = params.token();
     ProgressParams::ProgressType value = params.value();
-    if (auto begin = Utils::get_if<WorkDoneProgressBegin>(&value))
+    if (auto begin = std::get_if<WorkDoneProgressBegin>(&value))
         beginProgress(token, *begin);
-    else if (auto report = Utils::get_if<WorkDoneProgressReport>(&value))
+    else if (auto report = std::get_if<WorkDoneProgressReport>(&value))
         reportProgress(token, *report);
-    else if (auto end = Utils::get_if<WorkDoneProgressEnd>(&value))
+    else if (auto end = std::get_if<WorkDoneProgressEnd>(&value))
         endProgress(token, *end);
 }
 
@@ -68,16 +68,16 @@ void ProgressManager::reset()
 
 bool ProgressManager::isProgressEndMessage(const LanguageServerProtocol::ProgressParams &params)
 {
-    return Utils::holds_alternative<WorkDoneProgressEnd>(params.value());
+    return std::holds_alternative<WorkDoneProgressEnd>(params.value());
 }
 
 Utils::Id languageClientProgressId(const ProgressToken &token)
 {
     constexpr char k_LanguageClientProgressId[] = "LanguageClient.ProgressId.";
     auto toString = [](const ProgressToken &token){
-        if (Utils::holds_alternative<int>(token))
-            return QString::number(Utils::get<int>(token));
-        return Utils::get<QString>(token);
+        if (std::holds_alternative<int>(token))
+            return QString::number(std::get<int>(token));
+        return std::get<QString>(token);
     };
     return Utils::Id(k_LanguageClientProgressId).withSuffix(toString(token));
 }
diff --git a/src/plugins/languageclient/semantichighlightsupport.cpp b/src/plugins/languageclient/semantichighlightsupport.cpp
index 7fbf664591..4f01699321 100644
--- a/src/plugins/languageclient/semantichighlightsupport.cpp
+++ b/src/plugins/languageclient/semantichighlightsupport.cpp
@@ -356,7 +356,7 @@ void SemanticTokenSupport::handleSemanticTokens(const Utils::FilePath &filePath,
                                                 const SemanticTokensResult &result,
                                                 int documentVersion)
 {
-    if (auto tokens = Utils::get_if<SemanticTokens>(&result)) {
+    if (auto tokens = std::get_if<SemanticTokens>(&result)) {
         const bool force = !m_tokens.contains(filePath);
         m_tokens[filePath] = {*tokens, documentVersion};
         highlight(filePath, force);
@@ -369,10 +369,10 @@ void SemanticTokenSupport::handleSemanticTokensDelta(
     int documentVersion)
 {
     qCDebug(LOGLSPHIGHLIGHT) << "Handle Tokens for " << filePath;
-    if (auto tokens = Utils::get_if<SemanticTokens>(&result)) {
+    if (auto tokens = std::get_if<SemanticTokens>(&result)) {
         m_tokens[filePath] = {*tokens, documentVersion};
         qCDebug(LOGLSPHIGHLIGHT) << "New Data " << tokens->data();
-    } else if (auto tokensDelta = Utils::get_if<SemanticTokensDelta>(&result)) {
+    } else if (auto tokensDelta = std::get_if<SemanticTokensDelta>(&result)) {
         m_tokens[filePath].version = documentVersion;
         QList<SemanticTokensEdit> edits = tokensDelta->edits();
         if (edits.isEmpty()) {
diff --git a/src/plugins/languageclient/snippet.cpp b/src/plugins/languageclient/snippet.cpp
index 1270a9cc0b..284f565941 100644
--- a/src/plugins/languageclient/snippet.cpp
+++ b/src/plugins/languageclient/snippet.cpp
@@ -263,11 +263,11 @@ void LanguageClient::LanguageClientPlugin::testSnippetParsing()
     QFETCH(Parts, parts);
 
     SnippetParseResult result = LanguageClient::parseSnippet(input);
-    QCOMPARE(Utils::holds_alternative<ParsedSnippet>(result), success);
+    QCOMPARE(std::holds_alternative<ParsedSnippet>(result), success);
     if (!success)
         return;
 
-    ParsedSnippet snippet = Utils::get<ParsedSnippet>(result);
+    ParsedSnippet snippet = std::get<ParsedSnippet>(result);
 
     auto rangesCompare = [&](const ParsedSnippet::Part &actual, const SnippetPart &expected) {
         QCOMPARE(actual.text, expected.text);
diff --git a/src/plugins/projectexplorer/projectnodes.cpp b/src/plugins/projectexplorer/projectnodes.cpp
index 6df432d19d..01686539ea 100644
--- a/src/plugins/projectexplorer/projectnodes.cpp
+++ b/src/plugins/projectexplorer/projectnodes.cpp
@@ -470,18 +470,18 @@ QIcon FolderNode::icon() const
     QTC_CHECK(QThread::currentThread() == QCoreApplication::instance()->thread());
 
     // Instantiating the Icon provider is expensive.
-    if (auto strPtr = Utils::get_if<QString>(&m_icon)) {
+    if (auto strPtr = std::get_if<QString>(&m_icon)) {
         m_icon = QIcon(*strPtr);
-    } else if (auto directoryIconPtr = Utils::get_if<DirectoryIcon>(&m_icon)) {
+    } else if (auto directoryIconPtr = std::get_if<DirectoryIcon>(&m_icon)) {
         m_icon = directoryIconPtr->icon();
-    } else if (auto creatorPtr = Utils::get_if<IconCreator>(&m_icon)) {
+    } else if (auto creatorPtr = std::get_if<IconCreator>(&m_icon)) {
         m_icon = (*creatorPtr)();
     } else {
-        auto iconPtr = Utils::get_if<QIcon>(&m_icon);
+        auto iconPtr = std::get_if<QIcon>(&m_icon);
         if (!iconPtr || iconPtr->isNull())
             m_icon = Utils::FileIconProvider::icon(QFileIconProvider::Folder);
     }
-    return Utils::get<QIcon>(m_icon);
+    return std::get<QIcon>(m_icon);
 }
 
 Node *FolderNode::findNode(const std::function<bool(Node *)> &filter)
diff --git a/src/plugins/projectexplorer/projectnodes.h b/src/plugins/projectexplorer/projectnodes.h
index 9e2e4e9474..e0fa420b9b 100644
--- a/src/plugins/projectexplorer/projectnodes.h
+++ b/src/plugins/projectexplorer/projectnodes.h
@@ -34,9 +34,9 @@
 #include <utils/fileutils.h>
 #include <utils/id.h>
 #include <utils/optional.h>
-#include <utils/variant.h>
 
 #include <functional>
+#include <variant>
 
 namespace Utils { class MimeType; }
 
@@ -354,7 +354,7 @@ private:
 
     QString m_displayName;
     QString m_addFileFilter;
-    mutable Utils::variant<QIcon, DirectoryIcon, QString, IconCreator> m_icon;
+    mutable std::variant<QIcon, DirectoryIcon, QString, IconCreator> m_icon;
     bool m_showWhenEmpty = false;
 };
 
diff --git a/src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.cpp b/src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.cpp
index d7f2505895..a62613b5c0 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.cpp
+++ b/src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.cpp
@@ -108,7 +108,7 @@ void ImageCacheCollector::start(Utils::SmallStringView name,
     }
 
     if (is3DRoot) {
-        if (auto libIcon = Utils::get_if<ImageCache::LibraryIconAuxiliaryData>(&auxiliaryData))
+        if (auto libIcon = std::get_if<ImageCache::LibraryIconAuxiliaryData>(&auxiliaryData))
             rewriterView.rootModelNode().setAuxiliaryData(AuxiliaryDataType::NodeInstancePropertyOverwrite,
                                                           "isLibraryIcon",
                                                           libIcon->enable);
diff --git a/src/plugins/qmldesigner/designercore/imagecache/imagecachefontcollector.cpp b/src/plugins/qmldesigner/designercore/imagecache/imagecachefontcollector.cpp
index 3069600fd0..b59aa5b4bf 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/imagecachefontcollector.cpp
+++ b/src/plugins/qmldesigner/designercore/imagecache/imagecachefontcollector.cpp
@@ -128,7 +128,7 @@ void ImageCacheFontCollector::start(Utils::SmallStringView name,
 {
     QFont font;
     if (resolveFont(QString(name), font) >= 0) {
-        auto &&auxiliaryData = Utils::get<ImageCache::FontCollectorSizeAuxiliaryData>(auxiliaryDataValue);
+        auto &&auxiliaryData = std::get<ImageCache::FontCollectorSizeAuxiliaryData>(auxiliaryDataValue);
         QColor textColor = auxiliaryData.colorName;
         QSize size = auxiliaryData.size;
         QString text = font.family() + "\n" + auxiliaryData.text;
@@ -150,7 +150,7 @@ std::pair<QImage, QImage> ImageCacheFontCollector::createImage(
 {
     QFont font;
     if (resolveFont(QString(name), font) >= 0) {
-        auto &&auxiliaryData = Utils::get<ImageCache::FontCollectorSizeAuxiliaryData>(auxiliaryDataValue);
+        auto &&auxiliaryData = std::get<ImageCache::FontCollectorSizeAuxiliaryData>(auxiliaryDataValue);
         QColor textColor = auxiliaryData.colorName;
         QSize size = auxiliaryData.size;
         QString text = font.family() + "\n\n" + auxiliaryData.text;
@@ -172,7 +172,7 @@ QIcon ImageCacheFontCollector::createIcon(Utils::SmallStringView name,
 
     QFont font;
     if (resolveFont(QString(name), font) >= 0) {
-        auto &&auxiliaryData = Utils::get<ImageCache::FontCollectorSizesAuxiliaryData>(auxiliaryDataValue);
+        auto &&auxiliaryData = std::get<ImageCache::FontCollectorSizesAuxiliaryData>(auxiliaryDataValue);
         QColor textColor = auxiliaryData.colorName;
         const auto sizes = auxiliaryData.sizes;
         QString text = auxiliaryData.text;
diff --git a/src/plugins/qmldesigner/designercore/include/auxiliarydataproperties.h b/src/plugins/qmldesigner/designercore/include/auxiliarydataproperties.h
index c7193960ed..18788ea350 100644
--- a/src/plugins/qmldesigner/designercore/include/auxiliarydataproperties.h
+++ b/src/plugins/qmldesigner/designercore/include/auxiliarydataproperties.h
@@ -26,20 +26,20 @@
 #pragma once
 
 #include <auxiliarydata.h>
-#include <utils/variant.h>
 
 #include <QColor>
 #include <QVariant>
 
 #include <type_traits>
+#include <variant>
 
 namespace QmlDesigner {
 
-using PropertyValue = Utils::variant<int, long long, double, bool, QColor, QStringView, Qt::Corner>;
+using PropertyValue = std::variant<int, long long, double, bool, QColor, QStringView, Qt::Corner>;
 
 inline QVariant toQVariant(const PropertyValue &variant)
 {
-    return Utils::visit([](const auto &value) { return QVariant::fromValue(value); }, variant);
+    return std::visit([](const auto &value) { return QVariant::fromValue(value); }, variant);
 }
 
 class AuxiliaryDataKeyDefaultValue : public AuxiliaryDataKeyView
diff --git a/src/plugins/qmldesigner/designercore/include/imagecacheauxiliarydata.h b/src/plugins/qmldesigner/designercore/include/imagecacheauxiliarydata.h
index 61660271fc..153b61e9ee 100644
--- a/src/plugins/qmldesigner/designercore/include/imagecacheauxiliarydata.h
+++ b/src/plugins/qmldesigner/designercore/include/imagecacheauxiliarydata.h
@@ -26,13 +26,13 @@
 #pragma once
 
 #include <utils/span.h>
-#include <utils/variant.h>
 
 #include <QImage>
 #include <QSize>
 #include <QString>
 
 #include <functional>
+#include <variant>
 
 namespace QmlDesigner {
 
@@ -60,10 +60,10 @@ public:
     bool enable;
 };
 
-using AuxiliaryData = Utils::variant<Utils::monostate,
-                                     LibraryIconAuxiliaryData,
-                                     FontCollectorSizeAuxiliaryData,
-                                     FontCollectorSizesAuxiliaryData>;
+using AuxiliaryData = std::variant<std::monostate,
+                                   LibraryIconAuxiliaryData,
+                                   FontCollectorSizeAuxiliaryData,
+                                   FontCollectorSizesAuxiliaryData>;
 
 enum class AbortReason : char { Abort, Failed };
 
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h b/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h
index 1b2770d197..21a0e7e883 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h
+++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h
@@ -1910,7 +1910,7 @@ private:
         if (type.changeLevel == Storage::Synchronization::ChangeLevel::Minimal)
             return;
 
-        if (Utils::visit([](auto &&typeName) -> bool { return typeName.name.isEmpty(); },
+        if (std::visit([](auto &&typeName) -> bool { return typeName.name.isEmpty(); },
                          type.prototype)) {
             updatePrototypeStatement.write(type.typeId, Sqlite::NullValue{}, Sqlite::NullValue{});
         } else {
@@ -1981,7 +1981,7 @@ private:
             SourceId sourceId;
         };
 
-        return Utils::visit(Inspect{*this, sourceId}, name);
+        return std::visit(Inspect{*this, sourceId}, name);
     }
 
     template<typename Id>
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h b/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h
index 25be97f1eb..c4781d41ad 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h
+++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h
@@ -29,9 +29,9 @@
 #include "projectstorageids.h"
 
 #include <utils/smallstring.h>
-#include <utils/variant.h>
 
 #include <tuple>
+#include <variant>
 #include <vector>
 
 namespace QmlDesigner {
@@ -425,7 +425,7 @@ public:
     ExportedTypeNameId exportedTypeNameId;
 };
 
-using ImportedTypeName = Utils::variant<ImportedType, QualifiedImportedType>;
+using ImportedTypeName = std::variant<ImportedType, QualifiedImportedType>;
 
 class EnumeratorDeclaration
 {
diff --git a/src/plugins/texteditor/snippets/snippet.cpp b/src/plugins/texteditor/snippets/snippet.cpp
index 885b008026..6dec2efe5e 100644
--- a/src/plugins/texteditor/snippets/snippet.cpp
+++ b/src/plugins/texteditor/snippets/snippet.cpp
@@ -182,10 +182,10 @@ QString Snippet::generateTip() const
 {
     SnippetParseResult result = Snippet::parse(m_content);
 
-    if (Utils::holds_alternative<SnippetParseError>(result))
-        return Utils::get<SnippetParseError>(result).htmlMessage();
-    QTC_ASSERT(Utils::holds_alternative<ParsedSnippet>(result), return {});
-    const ParsedSnippet parsedSnippet = Utils::get<ParsedSnippet>(result);
+    if (std::holds_alternative<SnippetParseError>(result))
+        return std::get<SnippetParseError>(result).htmlMessage();
+    QTC_ASSERT(std::holds_alternative<ParsedSnippet>(result), return {});
+    const ParsedSnippet parsedSnippet = std::get<ParsedSnippet>(result);
 
     QString tip("<nobr>");
     for (const ParsedSnippet::Part &part : parsedSnippet.parts)
@@ -407,11 +407,11 @@ void Internal::TextEditorPlugin::testSnippetParsing()
     QFETCH(Parts, parts);
 
     SnippetParseResult result = Snippet::parse(input);
-    QCOMPARE(Utils::holds_alternative<ParsedSnippet>(result), success);
+    QCOMPARE(std::holds_alternative<ParsedSnippet>(result), success);
     if (!success)
         return;
 
-    ParsedSnippet snippet = Utils::get<ParsedSnippet>(result);
+    ParsedSnippet snippet = std::get<ParsedSnippet>(result);
 
     auto rangesCompare = [&](const ParsedSnippet::Part &actual, const SnippetPart &expected) {
         QCOMPARE(actual.text, expected.text);
diff --git a/src/plugins/texteditor/snippets/snippetparser.h b/src/plugins/texteditor/snippets/snippetparser.h
index 67d0560d02..887cdf6936 100644
--- a/src/plugins/texteditor/snippets/snippetparser.h
+++ b/src/plugins/texteditor/snippets/snippetparser.h
@@ -28,7 +28,8 @@
 #include <texteditor/texteditor_global.h>
 
 #include <utils/id.h>
-#include <utils/variant.h>
+
+#include <variant>
 
 namespace TextEditor {
 
@@ -67,7 +68,7 @@ public:
     QString htmlMessage() const;
 };
 
-using SnippetParseResult = Utils::variant<ParsedSnippet, SnippetParseError>;
+using SnippetParseResult = std::variant<ParsedSnippet, SnippetParseError>;
 using SnippetParser = std::function<SnippetParseResult (const QString &)>;
 
 } // namespace TextEditor
diff --git a/src/plugins/texteditor/texteditor.cpp b/src/plugins/texteditor/texteditor.cpp
index 969be964bf..4ed97382b7 100644
--- a/src/plugins/texteditor/texteditor.cpp
+++ b/src/plugins/texteditor/texteditor.cpp
@@ -2761,13 +2761,13 @@ void TextEditorWidget::insertCodeSnippet(const QTextCursor &cursor_arg,
                                          const SnippetParser &parse)
 {
     SnippetParseResult result = parse(snippet);
-    if (Utils::holds_alternative<SnippetParseError>(result)) {
-        const auto &error = Utils::get<SnippetParseError>(result);
+    if (std::holds_alternative<SnippetParseError>(result)) {
+        const auto &error = std::get<SnippetParseError>(result);
         QMessageBox::warning(this, tr("Snippet Parse Error"), error.htmlMessage());
         return;
     }
-    QTC_ASSERT(Utils::holds_alternative<ParsedSnippet>(result), return);
-    ParsedSnippet data = Utils::get<ParsedSnippet>(result);
+    QTC_ASSERT(std::holds_alternative<ParsedSnippet>(result), return);
+    ParsedSnippet data = std::get<ParsedSnippet>(result);
 
     QTextCursor cursor = cursor_arg;
     cursor.beginEditBlock();
diff --git a/tests/unit/unittest/asynchronousimagefactory-test.cpp b/tests/unit/unittest/asynchronousimagefactory-test.cpp
index cc23374a57..f307c38327 100644
--- a/tests/unit/unittest/asynchronousimagefactory-test.cpp
+++ b/tests/unit/unittest/asynchronousimagefactory-test.cpp
@@ -62,7 +62,7 @@ TEST_F(AsynchronousImageFactory, RequestImageRequestImageFromCollector)
     EXPECT_CALL(collectorMock,
                 start(Eq("/path/to/Component.qml"),
                       IsEmpty(),
-                      VariantWith<Utils::monostate>(Utils::monostate{}),
+                      VariantWith<std::monostate>(std::monostate{}),
                       _,
                       _))
         .WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
@@ -76,7 +76,7 @@ TEST_F(AsynchronousImageFactory, RequestImageWithExtraIdRequestImageFromCollecto
     EXPECT_CALL(collectorMock,
                 start(Eq("/path/to/Component.qml"),
                       Eq("foo"),
-                      VariantWith<Utils::monostate>(Utils::monostate{}),
+                      VariantWith<std::monostate>(std::monostate{}),
                       _,
                       _))
         .WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
@@ -162,7 +162,7 @@ TEST_F(AsynchronousImageFactory, AfterCleanNewJobsWorks)
     EXPECT_CALL(collectorMock,
                 start(Eq("/path/to/Component.qml"),
                       IsEmpty(),
-                      VariantWith<Utils::monostate>(Utils::monostate{}),
+                      VariantWith<std::monostate>(std::monostate{}),
                       _,
                       _))
         .WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
@@ -181,7 +181,7 @@ TEST_F(AsynchronousImageFactory, CaptureImageCallbackStoresImage)
     ON_CALL(collectorMock,
             start(Eq("/path/to/Component.qml"),
                   Eq("id"),
-                  VariantWith<Utils::monostate>(Utils::monostate{}),
+                  VariantWith<std::monostate>(std::monostate{}),
                   _,
                   _))
         .WillByDefault([&](auto, auto, auto, auto capture, auto) { capture(image1, smallImage1); });
diff --git a/tests/unit/unittest/gtest-creator-printing.cpp b/tests/unit/unittest/gtest-creator-printing.cpp
index 93b19f39ea..2c6046740a 100644
--- a/tests/unit/unittest/gtest-creator-printing.cpp
+++ b/tests/unit/unittest/gtest-creator-printing.cpp
@@ -33,6 +33,7 @@
 
 #include <clangtools/clangtoolsdiagnostic.h>
 #include <debugger/analyzer/diagnosticlocation.h>
+#include <imagecacheauxiliarydata.h>
 #include <modelnode.h>
 #include <projectstorage/filestatus.h>
 #include <projectstorage/projectstoragepathwatchertypes.h>
@@ -54,6 +55,12 @@ template <typename T> ostream &operator<<(ostream &out, const QVector<T> &vector
     out << "]";
     return out;
 }
+
+std::ostream &operator<<(std::ostream &out, const monostate &)
+{
+    return out << "monostate";
+}
+
 } // namespace std
 
 namespace Utils {
@@ -739,6 +746,7 @@ std::ostream &operator<<(std::ostream &out, const QualifiedImportedType &importe
 
 std::ostream &operator<<(std::ostream &out, const Type &type)
 {
+    using std::operator<<;
     using Utils::operator<<;
     return out << "( typename: \"" << type.typeName << "\", prototype: " << type.prototype << ", "
                << type.prototypeId << ", " << type.traits << ", source: " << type.sourceId
@@ -813,4 +821,20 @@ std::ostream &operator<<(std::ostream &out, const ModuleExportedImport &import)
 
 } // namespace Storage::Synchronization
 
+namespace ImageCache {
+
+std::ostream &operator<<(std::ostream &out, const LibraryIconAuxiliaryData &data)
+{
+    return out << "(" << data.enable << ")";
+}
+std::ostream &operator<<(std::ostream &out, const FontCollectorSizeAuxiliaryData &data)
+{
+    return out << "(" << data.text << ", " << data.size << ", " << data.colorName << ")";
+}
+std::ostream &operator<<(std::ostream &out, const FontCollectorSizesAuxiliaryData &data)
+{
+    return out << "(" << data.text << ", " << data.colorName << ")";
+}
+} // namespace ImageCache
+
 } // namespace QmlDesigner
diff --git a/tests/unit/unittest/gtest-creator-printing.h b/tests/unit/unittest/gtest-creator-printing.h
index 407f16e53e..ea51650f9c 100644
--- a/tests/unit/unittest/gtest-creator-printing.h
+++ b/tests/unit/unittest/gtest-creator-printing.h
@@ -28,11 +28,11 @@
 #include <utils/cpplanguage_details.h>
 #include <utils/optional.h>
 #include <utils/smallstringio.h>
-#include <utils/variant.h>
 
 #include <QtGlobal>
 
 #include <iosfwd>
+#include <variant>
 
 #include <gtest/gtest-printers.h>
 
@@ -77,6 +77,18 @@ std::ostream &operator<<(std::ostream &out, const ValueViews &valueViews);
 } // namespace SessionChangeSetInternal
 } // namespace Sqlite
 
+namespace std {
+
+template<typename Type, typename... Types>
+std::ostream &operator<<(std::ostream &out, const variant<Type, Types...> &v)
+{
+    return visit([&](auto &&value) -> std::ostream & { return out << value; }, v);
+}
+
+std::ostream &operator<<(std::ostream &out, const monostate &);
+
+} // namespace std
+
 namespace Utils {
 class LineColumn;
 class SmallStringView;
@@ -103,12 +115,6 @@ void PrintTo(const optional<Type> &optional, ::std::ostream *os)
     *os << optional;
 }
 
-template<typename... Type>
-std::ostream &operator<<(std::ostream &out, const variant<Type...> &variant)
-{
-    return Utils::visit([&](auto &&value) -> std::ostream & { return out << value; }, variant);
-}
-
 void PrintTo(Utils::SmallStringView text, ::std::ostream *os);
 void PrintTo(const Utils::SmallString &text, ::std::ostream *os);
 void PrintTo(const Utils::PathString &text, ::std::ostream *os);
@@ -152,6 +158,16 @@ class SourceContext;
 std::ostream &operator<<(std::ostream &out, const SourceContext &sourceContext);
 } // namespace Cache
 
+namespace ImageCache {
+class LibraryIconAuxiliaryData;
+class FontCollectorSizeAuxiliaryData;
+class FontCollectorSizesAuxiliaryData;
+
+std::ostream &operator<<(std::ostream &out, const LibraryIconAuxiliaryData &date);
+std::ostream &operator<<(std::ostream &out, const FontCollectorSizeAuxiliaryData &sourceContext);
+std::ostream &operator<<(std::ostream &out, const FontCollectorSizesAuxiliaryData &sourceContext);
+} // namespace ImageCache
+
 namespace Storage {
 enum class PropertyDeclarationTraits : int;
 enum class TypeTraits : int;