Utils: Remove Utils::optional

Since we are now requiring macOS 10.14 we can remove our local implementation of optional and use std::optional for macOS too. Change-Id: I2bd018261b68da64f7f031a812045dd7784697e1 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Marco Bubke <marco.bubke@qt.io>
author: Eike Ziller <eike.ziller@qt.io> 2022-08-26 10:30:00 +0200
committer: Eike Ziller <eike.ziller@qt.io> 2022-09-01 06:58:04 +0000
commit: 04e50438eb85c1b2be6d4dcdfd5319cdb55ae576 (patch)
tree: 4a3e9f078730bb538e2ca2751d189ff14a89901e
parent: 34a9491a08639f8df0b55d74d51f4dadaa1cc2fd (diff)
247 files changed, 1053 insertions, 3751 deletions
diff --git a/README.md b/README.md
index 5a979e0ff0..50c10733d6 100644
--- a/README.md
+++ b/README.md
@@ -324,24 +324,6 @@ we thank the authors who made this possible:
 
   With backported/additional patches from https://code.qt.io/cgit/clang/llvm-project.git
 
-### Optional
-
-  A single-header header-only library for representing optional (nullable)
-  objects for C++14 (and C++11 to some extent) and passing them by value.
-
-  https://github.com/akrzemi1/Optional
-
-  QtCreator/src/libs/3rdparty/optional
-
-  Copyright (C) 2011-2012 Andrzej Krzemienski
-
-  Distributed under the Boost Software License, Version 1.0
-  (see accompanying file LICENSE_1_0.txt or a copy at
-  http://www.boost.org/LICENSE_1_0.txt)
-
-  The idea and interface is based on Boost.Optional library
-  authored by Fernando Luis Cacciola Carballal
-
 ### std::span implementation for C++11 and later
 
   A single-header implementation of C++20's std::span, conforming to the C++20
diff --git a/doc/qtcreator/src/overview/creator-acknowledgements.qdoc b/doc/qtcreator/src/overview/creator-acknowledgements.qdoc
index 8f414b299c..49b658e003 100644
--- a/doc/qtcreator/src/overview/creator-acknowledgements.qdoc
+++ b/doc/qtcreator/src/overview/creator-acknowledgements.qdoc
@@ -362,29 +362,6 @@
             \li \l{https://code.qt.io/cgit/clang/llvm-project.git}
             \endlist
 
-        \li \b{Optional}
-
-            A single-header header-only library for representing optional
-            (nullable) objects for C++14 (and C++11 to some extent) and passing
-            them by value.
-
-            Copyright (C) 2011-2012 Andrzej Krzemienski
-
-            Distributed under the \l {http://boost.org/LICENSE_1_0.txt}
-            {Boost Software License, Version 1.0}.
-            (See accompanying file LICENSE_1_0.txt)
-
-            The idea and interface is based on Boost.Optional library
-            authored by Fernando Luis Cacciola Carballal
-
-            The source code of std::experimental::optional can be found
-            here:
-            \list
-            \li \l{https://github.com/akrzemi1/Optional}
-            \li QtCreator/src/libs/3rdparty/optional
-            \li \l{https://code.qt.io/cgit/qt-creator/qt-creator.git/tree/src/libs/3rdparty/optional}
-            \endlist
-
         \li \b{std::span implementation for C++11 and later}
 
             A single-header implementation of C++20's std::span, conforming to
diff --git a/src/app/main.cpp b/src/app/main.cpp
index be2f0ddd2f..35e3ccb762 100644
--- a/src/app/main.cpp
+++ b/src/app/main.cpp
@@ -15,7 +15,6 @@
 #include <utils/fileutils.h>
 #include <utils/fsengine/fsengine.h>
 #include <utils/hostosinfo.h>
-#include <utils/optional.h>
 #include <utils/qtcsettings.h>
 #include <utils/singleton.h>
 #include <utils/temporarydirectory.h>
@@ -47,9 +46,10 @@
 #include <QTemporaryDir>
 #include <QTextCodec>
 
+#include <iterator>
+#include <optional>
 #include <string>
 #include <vector>
-#include <iterator>
 
 #ifdef ENABLE_QT_BREAKPAD
 #include <qtsystemexceptionhandler.h>
@@ -295,7 +295,7 @@ struct Options
     QStringList preAppArguments;
     // list of arguments to be passed to the application or plugin manager
     std::vector<char *> appArguments;
-    Utils::optional<QString> userLibraryPath;
+    std::optional<QString> userLibraryPath;
     bool hasTestOption = false;
     bool wantsCleanSettings = false;
 };
diff --git a/src/libs/3rdparty/optional/CMakeLists.txt b/src/libs/3rdparty/optional/CMakeLists.txt
deleted file mode 100644
index 07f38f7993..0000000000
--- a/src/libs/3rdparty/optional/CMakeLists.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-project(optional)
-cmake_minimum_required(VERSION 2.8)
-enable_testing()
-
-set(CMAKE_CXX_FLAGS "-std=c++11 -Wall -Wextra")
-
-add_executable(test_optional test_optional.cpp)
-add_executable(test_type_traits test_type_traits.cpp)
-
-add_test(test_optional test_optional)
-add_test(test_type_traits test_type_traits)
diff --git a/src/libs/3rdparty/optional/LICENSE_1_0.txt b/src/libs/3rdparty/optional/LICENSE_1_0.txt
deleted file mode 100644
index 36b7cd93cd..0000000000
--- a/src/libs/3rdparty/optional/LICENSE_1_0.txt
+++ /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/optional/README.md b/src/libs/3rdparty/optional/README.md
deleted file mode 100644
index 948516d1ba..0000000000
--- a/src/libs/3rdparty/optional/README.md
+++ /dev/null
@@ -1,39 +0,0 @@
-Optional
-========
-
-A single-header header-only library for representing optional (nullable) objects for C++14 (and C++11 to some extent) and passing them by value. This is the reference implementation of proposal N3793 (see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3793.html). Optional is now accepted into Library Fundamentals Technical Specification (see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3848.html). The interface is based on Fernando Cacciola's Boost.Optional library (see http://www.boost.org/doc/libs/1_52_0/libs/optional/doc/html/index.html)
-
-
-Usage
------
-
-```cpp
-optional<int> readInt(); // this function may return int or a not-an-int
-
-if (optional<int> oi = readInt()) // did I get a real int
-  cout << "my int is: " << *oi;   // use my int
-else
-  cout << "I have no int";
-```
-
-For more usage examples and the overview see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3527.html
-
-
-Supported compilers
--------------------
-
-Clang 3.2, Clang 3.4, G++ 4.7.2, G++ 4.8.1. Tested only with libstdc++, versions 20130531, 20120920, 20110428. Others have reported it also works with libc++.
-
-
-
-Known Issues
-------------
-
- - Currently, the reference (and the only known) implementation of certain pieces of functionality explore what C++11 identifies as undefined behavior (see national body comment FI 15: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3770.html#FI15). This is mostly why Optional was removed from C++14 and put into Library Fundamentals TS. Luckily what the Standard identifies as UB is well defined on all known platforms. We expect that the C++14 wil fix this problem, so that our trick becomes well-defined.
- - In libstdc++ versions below 20130531 the constructor taking `initializer_list` argument is not `constexpr`. This is because `initializer_list` operations are not `constexpr` in C++11. This works however in version 20130531. It is also not enabled for libc++ because I do not have access to it and do nto know if it provides `constexpr` `initializer_list`.
- - In G++ 4.7.2 and 4.8.0 member function `value_or` does not have rvalue reference overload. These compilers do not support rvalue overloding on `*this`.
- - In order for the library to work with slightly older compilers, we emulate some missing type traits. On some platforms we cannot correctly detect the available features, and attempts at workarounds for missing type trait definitions can cause compile-time errors. Define macro `TR2_OPTIONAL_DISABLE_EMULATION_OF_TYPE_TRAITS` if you know that all the necessary type traits are defined, and no emulation is required.
-
-License
--------
-Distributed under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
diff --git a/src/libs/3rdparty/optional/copyright.txt b/src/libs/3rdparty/optional/copyright.txt
deleted file mode 100644
index 1641c3cdd0..0000000000
--- a/src/libs/3rdparty/optional/copyright.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-Copyright (C) 2011-2012 Andrzej Krzemienski
-
-Distributed under the Boost Software License, Version 1.0
-(see accompanying file LICENSE_1_0.txt or a copy at
-http://www.boost.org/LICENSE_1_0.txt)
-
-The idea and interface is based on Boost.Optional library
-authored by Fernando Luis Cacciola Carballal
-
-Home at https://github.com/akrzemi1/Optional
-\ No newline at end of file
diff --git a/src/libs/3rdparty/optional/optional.hpp b/src/libs/3rdparty/optional/optional.hpp
deleted file mode 100644
index 607696d8e1..0000000000
--- a/src/libs/3rdparty/optional/optional.hpp
+++ /dev/null
@@ -1,1046 +0,0 @@
-// Copyright (C) 2011 - 2012 Andrzej Krzemienski.
-//
-// Use, modification, and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// The idea and interface is based on Boost.Optional library
-// authored by Fernando Luis Cacciola Carballal
-
-# ifndef ___OPTIONAL_HPP___
-# define ___OPTIONAL_HPP___
-
-# include <utility>
-# include <type_traits>
-# include <initializer_list>
-# include <cassert>
-# include <functional>
-# include <string>
-# include <stdexcept>
-
-# define TR2_OPTIONAL_REQUIRES(...) typename enable_if<__VA_ARGS__::value, bool>::type = false
-
-# if defined __GNUC__ // NOTE: GNUC is also defined for Clang
-#   if (__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)
-#     define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
-#   elif (__GNUC__ > 4)
-#     define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
-#   endif
-#
-#   if (__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)
-#     define TR2_OPTIONAL_GCC_4_7_AND_HIGHER___
-#   elif (__GNUC__ > 4)
-#     define TR2_OPTIONAL_GCC_4_7_AND_HIGHER___
-#   endif
-#
-#   if (__GNUC__ == 4) && (__GNUC_MINOR__ == 8) && (__GNUC_PATCHLEVEL__ >= 1)
-#     define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
-#   elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)
-#     define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
-#   elif (__GNUC__ > 4)
-#     define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
-#   endif
-# endif
-#
-# if defined __clang_major__
-#   if (__clang_major__ == 3 && __clang_minor__ >= 5)
-#     define TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_
-#   elif (__clang_major__ > 3)
-#     define TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_
-#   endif
-#   if defined TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_
-#     define TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
-#   elif (__clang_major__ == 3 && __clang_minor__ == 4 && __clang_patchlevel__ >= 2)
-#     define TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
-#   endif
-# endif
-#
-# if defined _MSC_VER
-#   if (_MSC_VER >= 1900)
-#     define TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
-#   endif
-# endif
-
-# if defined __clang__
-#   if (__clang_major__ > 2) || (__clang_major__ == 2) && (__clang_minor__ >= 9)
-#     define OPTIONAL_HAS_THIS_RVALUE_REFS 1
-#   else
-#     define OPTIONAL_HAS_THIS_RVALUE_REFS 0
-#   endif
-# elif defined TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
-#   define OPTIONAL_HAS_THIS_RVALUE_REFS 1
-# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
-#   define OPTIONAL_HAS_THIS_RVALUE_REFS 1
-# else
-#   define OPTIONAL_HAS_THIS_RVALUE_REFS 0
-# endif
-
-
-# if defined TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
-#   define OPTIONAL_HAS_CONSTEXPR_INIT_LIST 1
-#   define OPTIONAL_CONSTEXPR_INIT_LIST constexpr
-# else
-#   define OPTIONAL_HAS_CONSTEXPR_INIT_LIST 0
-#   define OPTIONAL_CONSTEXPR_INIT_LIST
-# endif
-
-# if defined TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_ && (defined __cplusplus) && (__cplusplus != 201103L)
-#   define OPTIONAL_HAS_MOVE_ACCESSORS 1
-# else
-#   define OPTIONAL_HAS_MOVE_ACCESSORS 0
-# endif
-
-# // In C++11 constexpr implies const, so we need to make non-const members also non-constexpr
-# if (defined __cplusplus) && (__cplusplus == 201103L)
-#   define OPTIONAL_MUTABLE_CONSTEXPR
-# else
-#   define OPTIONAL_MUTABLE_CONSTEXPR constexpr
-# endif
-
-namespace std{
-
-namespace experimental{
-
-// BEGIN workaround for missing is_trivially_destructible
-# if defined TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
-    // leave it: it is already there
-# elif defined TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
-    // leave it: it is already there
-# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
-    // leave it: it is already there
-# elif defined TR2_OPTIONAL_DISABLE_EMULATION_OF_TYPE_TRAITS
-    // leave it: the user doesn't want it
-# else
-	template <typename T>
-	using is_trivially_destructible = std::has_trivial_destructor<T>;
-# endif
-// END workaround for missing is_trivially_destructible
-
-# if (defined TR2_OPTIONAL_GCC_4_7_AND_HIGHER___)
-    // leave it; our metafunctions are already defined.
-# elif defined TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
-    // leave it; our metafunctions are already defined.
-# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
-    // leave it: it is already there
-# elif defined TR2_OPTIONAL_DISABLE_EMULATION_OF_TYPE_TRAITS
-    // leave it: the user doesn't want it
-# else
-
-
-// workaround for missing traits in GCC and CLANG
-template <class T>
-struct is_nothrow_move_constructible
-{
-  constexpr static bool value = std::is_nothrow_constructible<T, T&&>::value;
-};
-
-
-template <class T, class U>
-struct is_assignable
-{
-  template <class X, class Y>
-  constexpr static bool has_assign(...) { return false; }
-
-  template <class X, class Y, size_t S = sizeof((std::declval<X>() = std::declval<Y>(), true)) >
-  // the comma operator is necessary for the cases where operator= returns void
-  constexpr static bool has_assign(bool) { return true; }
-
-  constexpr static bool value = has_assign<T, U>(true);
-};
-
-
-template <class T>
-struct is_nothrow_move_assignable
-{
-  template <class X, bool has_any_move_assign>
-  struct has_nothrow_move_assign {
-    constexpr static bool value = false;
-  };
-
-  template <class X>
-  struct has_nothrow_move_assign<X, true> {
-    constexpr static bool value = noexcept( std::declval<X&>() = std::declval<X&&>() );
-  };
-
-  constexpr static bool value = has_nothrow_move_assign<T, is_assignable<T&, T&&>::value>::value;
-};
-// end workaround
-
-
-# endif
-
-
-
-// 20.5.4, optional for object types
-template <class T> class optional;
-
-// 20.5.5, optional for lvalue reference types
-template <class T> class optional<T&>;
-
-
-// workaround: std utility functions aren't constexpr yet
-template <class T> inline constexpr T&& constexpr_forward(typename std::remove_reference<T>::type& t) noexcept
-{
-  return static_cast<T&&>(t);
-}
-
-template <class T> inline constexpr T&& constexpr_forward(typename std::remove_reference<T>::type&& t) noexcept
-{
-    static_assert(!std::is_lvalue_reference<T>::value, "!!");
-    return static_cast<T&&>(t);
-}
-
-template <class T> inline constexpr typename std::remove_reference<T>::type&& constexpr_move(T&& t) noexcept
-{
-    return static_cast<typename std::remove_reference<T>::type&&>(t);
-}
-
-
-#if defined NDEBUG
-# define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) (EXPR)
-#else
-# define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) ((CHECK) ? (EXPR) : ([]{assert(!#CHECK);}(), (EXPR)))
-#endif
-
-
-namespace detail_
-{
-
-// static_addressof: a constexpr version of addressof
-template <typename T>
-struct has_overloaded_addressof
-{
-  template <class X>
-  constexpr static bool has_overload(...) { return false; }
-  
-  template <class X, size_t S = sizeof(std::declval<X&>().operator&()) >
-  constexpr static bool has_overload(bool) { return true; }
-
-  constexpr static bool value = has_overload<T>(true);
-};
-
-template <typename T, TR2_OPTIONAL_REQUIRES(!has_overloaded_addressof<T>)>
-constexpr T* static_addressof(T& ref)
-{
-  return &ref;
-}
-
-template <typename T, TR2_OPTIONAL_REQUIRES(has_overloaded_addressof<T>)>
-T* static_addressof(T& ref)
-{
-  return std::addressof(ref);
-}
-
-
-// the call to convert<A>(b) has return type A and converts b to type A iff b decltype(b) is implicitly convertible to A  
-template <class U>
-constexpr U convert(U v) { return v; }
-  
-} // namespace detail
-
-
-constexpr struct trivial_init_t{} trivial_init{};
-
-
-// 20.5.6, In-place construction
-constexpr struct in_place_t{} in_place{};
-
-
-// 20.5.7, Disengaged state indicator
-struct nullopt_t
-{
-  struct init{};
-  constexpr explicit nullopt_t(init){}
-};
-constexpr nullopt_t nullopt{nullopt_t::init()};
-
-
-// 20.5.8, class bad_optional_access
-class bad_optional_access : public logic_error {
-public:
-  explicit bad_optional_access(const string& what_arg) : logic_error{what_arg} {}
-  explicit bad_optional_access(const char* what_arg) : logic_error{what_arg} {}
-};
-
-
-template <class T>
-union storage_t
-{
-  unsigned char dummy_;
-  T value_;
-
-  constexpr storage_t( trivial_init_t ) noexcept : dummy_() {};
-
-  template <class... Args>
-  constexpr storage_t( Args&&... args ) : value_(constexpr_forward<Args>(args)...) {}
-
-  ~storage_t(){}
-};
-
-
-template <class T>
-union constexpr_storage_t
-{
-    unsigned char dummy_;
-    T value_;
-
-    constexpr constexpr_storage_t( trivial_init_t ) noexcept : dummy_() {};
-
-    template <class... Args>
-    constexpr constexpr_storage_t( Args&&... args ) : value_(constexpr_forward<Args>(args)...) {}
-
-    ~constexpr_storage_t() = default;
-};
-
-
-template <class T>
-struct optional_base
-{
-    bool init_;
-    storage_t<T> storage_;
-
-    constexpr optional_base() noexcept : init_(false), storage_(trivial_init) {};
-
-    explicit constexpr optional_base(const T& v) : init_(true), storage_(v) {}
-
-    explicit constexpr optional_base(T&& v) : init_(true), storage_(constexpr_move(v)) {}
-
-    template <class... Args> explicit optional_base(in_place_t, Args&&... args)
-        : init_(true), storage_(constexpr_forward<Args>(args)...) {}
-
-    template <class U, class... Args, TR2_OPTIONAL_REQUIRES(is_constructible<T, std::initializer_list<U>>)>
-    explicit optional_base(in_place_t, std::initializer_list<U> il, Args&&... args)
-        : init_(true), storage_(il, std::forward<Args>(args)...) {}
-
-    ~optional_base() { if (init_) storage_.value_.T::~T(); }
-};
-
-
-template <class T>
-struct constexpr_optional_base
-{
-    bool init_;
-    constexpr_storage_t<T> storage_;
-
-    constexpr constexpr_optional_base() noexcept : init_(false), storage_(trivial_init) {};
-
-    explicit constexpr constexpr_optional_base(const T& v) : init_(true), storage_(v) {}
-
-    explicit constexpr constexpr_optional_base(T&& v) : init_(true), storage_(constexpr_move(v)) {}
-
-    template <class... Args> explicit constexpr constexpr_optional_base(in_place_t, Args&&... args)
-      : init_(true), storage_(constexpr_forward<Args>(args)...) {}
-
-    template <class U, class... Args, TR2_OPTIONAL_REQUIRES(is_constructible<T, std::initializer_list<U>>)>
-    OPTIONAL_CONSTEXPR_INIT_LIST explicit constexpr_optional_base(in_place_t, std::initializer_list<U> il, Args&&... args)
-      : init_(true), storage_(il, std::forward<Args>(args)...) {}
-
-    ~constexpr_optional_base() = default;
-};
-
-template <class T>
-using OptionalBase = typename std::conditional<
-    is_trivially_destructible<T>::value,
-    constexpr_optional_base<typename std::remove_const<T>::type>,
-    optional_base<typename std::remove_const<T>::type>
->::type;
-
-
-
-template <class T>
-class optional : private OptionalBase<T>
-{
-  static_assert( !std::is_same<typename std::decay<T>::type, nullopt_t>::value, "bad T" );
-  static_assert( !std::is_same<typename std::decay<T>::type, in_place_t>::value, "bad T" );
-  
-
-  constexpr bool initialized() const noexcept { return OptionalBase<T>::init_; }
-  typename std::remove_const<T>::type* dataptr() {  return std::addressof(OptionalBase<T>::storage_.value_); }
-  constexpr const T* dataptr() const { return detail_::static_addressof(OptionalBase<T>::storage_.value_); }
-  
-# if OPTIONAL_HAS_THIS_RVALUE_REFS == 1
-  constexpr const T& contained_val() const& { return OptionalBase<T>::storage_.value_; }
-#   if OPTIONAL_HAS_MOVE_ACCESSORS == 1
-  OPTIONAL_MUTABLE_CONSTEXPR T&& contained_val() && { return std::move(OptionalBase<T>::storage_.value_); }
-  OPTIONAL_MUTABLE_CONSTEXPR T& contained_val() & { return OptionalBase<T>::storage_.value_; }
-#   else
-  T& contained_val() & { return OptionalBase<T>::storage_.value_; }
-  T&& contained_val() && { return std::move(OptionalBase<T>::storage_.value_); }
-#   endif
-# else
-  constexpr const T& contained_val() const { return OptionalBase<T>::storage_.value_; }
-  T& contained_val() { return OptionalBase<T>::storage_.value_; }
-# endif
-
-  void clear() noexcept {
-    if (initialized()) dataptr()->T::~T();
-    OptionalBase<T>::init_ = false;
-  }
-  
-  template <class... Args>
-  void initialize(Args&&... args) noexcept(noexcept(T(std::forward<Args>(args)...)))
-  {
-    assert(!OptionalBase<T>::init_);
-    ::new (static_cast<void*>(dataptr())) T(std::forward<Args>(args)...);
-    OptionalBase<T>::init_ = true;
-  }
-
-  template <class U, class... Args>
-  void initialize(std::initializer_list<U> il, Args&&... args) noexcept(noexcept(T(il, std::forward<Args>(args)...)))
-  {
-    assert(!OptionalBase<T>::init_);
-    ::new (static_cast<void*>(dataptr())) T(il, std::forward<Args>(args)...);
-    OptionalBase<T>::init_ = true;
-  }
-
-public:
-  typedef T value_type;
-
-  // 20.5.5.1, constructors
-  constexpr optional() noexcept : OptionalBase<T>()  {};
-  constexpr optional(nullopt_t) noexcept : OptionalBase<T>() {};
-
-  optional(const optional& rhs)
-  : OptionalBase<T>()
-  {
-    if (rhs.initialized()) {
-        ::new (static_cast<void*>(dataptr())) T(*rhs);
-        OptionalBase<T>::init_ = true;
-    }
-  }
-
-  optional(optional&& rhs) noexcept(is_nothrow_move_constructible<T>::value)
-  : OptionalBase<T>()
-  {
-    if (rhs.initialized()) {
-        ::new (static_cast<void*>(dataptr())) T(std::move(*rhs));
-        OptionalBase<T>::init_ = true;
-    }
-  }
-
-  constexpr optional(const T& v) : OptionalBase<T>(v) {}
-
-  constexpr optional(T&& v) : OptionalBase<T>(constexpr_move(v)) {}
-
-  template <class... Args>
-  explicit constexpr optional(in_place_t, Args&&... args)
-  : OptionalBase<T>(in_place_t{}, constexpr_forward<Args>(args)...) {}
-
-  template <class U, class... Args, TR2_OPTIONAL_REQUIRES(is_constructible<T, std::initializer_list<U>>)>
-  OPTIONAL_CONSTEXPR_INIT_LIST explicit optional(in_place_t, std::initializer_list<U> il, Args&&... args)
-  : OptionalBase<T>(in_place_t{}, il, constexpr_forward<Args>(args)...) {}
-
-  // 20.5.4.2, Destructor
-  ~optional() = default;
-
-  void reset() noexcept { clear(); }
-
-  // 20.5.4.3, assignment
-  optional& operator=(nullopt_t) noexcept
-  {
-    clear();
-    return *this;
-  }
-  
-  optional& operator=(const optional& rhs)
-  {
-    if      (initialized() == true  && rhs.initialized() == false) clear();
-    else if (initialized() == false && rhs.initialized() == true)  initialize(*rhs);
-    else if (initialized() == true  && rhs.initialized() == true)  contained_val() = *rhs;
-    return *this;
-  }
-  
-  optional& operator=(optional&& rhs)
-  noexcept(is_nothrow_move_assignable<T>::value && is_nothrow_move_constructible<T>::value)
-  {
-    if      (initialized() == true  && rhs.initialized() == false) clear();
-    else if (initialized() == false && rhs.initialized() == true)  initialize(std::move(*rhs));
-    else if (initialized() == true  && rhs.initialized() == true)  contained_val() = std::move(*rhs);
-    return *this;
-  }
-
-  template <class U>
-  auto operator=(U&& v)
-  -> typename enable_if
-  <
-    is_same<typename decay<U>::type, T>::value,
-    optional&
-  >::type
-  {
-    if (initialized()) { contained_val() = std::forward<U>(v); }
-    else               { initialize(std::forward<U>(v));  }
-    return *this;
-  }
-  
-  
-  template <class... Args>
-  void emplace(Args&&... args)
-  {
-    clear();
-    initialize(std::forward<Args>(args)...);
-  }
-  
-  template <class U, class... Args>
-  void emplace(initializer_list<U> il, Args&&... args)
-  {
-    clear();
-    initialize<U, Args...>(il, std::forward<Args>(args)...);
-  }
-  
-  // 20.5.4.4, Swap
-  void swap(optional<T>& rhs) noexcept(is_nothrow_move_constructible<T>::value && noexcept(swap(declval<T&>(), declval<T&>())))
-  {
-    if      (initialized() == true  && rhs.initialized() == false) { rhs.initialize(std::move(**this)); clear(); }
-    else if (initialized() == false && rhs.initialized() == true)  { initialize(std::move(*rhs)); rhs.clear(); }
-    else if (initialized() == true  && rhs.initialized() == true)  { using std::swap; swap(**this, *rhs); }
-  }
-
-  // 20.5.4.5, Observers
-  
-  explicit constexpr operator bool() const noexcept { return initialized(); }
-  constexpr bool has_value() const noexcept { return initialized(); }
-  
-  constexpr T const* operator ->() const {
-    return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), dataptr());
-  }
-  
-# if OPTIONAL_HAS_MOVE_ACCESSORS == 1
-
-  OPTIONAL_MUTABLE_CONSTEXPR T* operator ->() {
-    assert (initialized());
-    return dataptr();
-  }
-  
-  constexpr T const& operator *() const& {
-    return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), contained_val());
-  }
-  
-  OPTIONAL_MUTABLE_CONSTEXPR T& operator *() & {
-    assert (initialized());
-    return contained_val();
-  }
-  
-  OPTIONAL_MUTABLE_CONSTEXPR T&& operator *() && {
-    assert (initialized());
-    return constexpr_move(contained_val());
-  }
-
-  constexpr T const& value() const& {
-    return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
-  }
-  
-  OPTIONAL_MUTABLE_CONSTEXPR T& value() & {
-    return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
-  }
-  
-  OPTIONAL_MUTABLE_CONSTEXPR T&& value() && {
-    if (!initialized()) throw bad_optional_access("bad optional access");
-	return std::move(contained_val());
-  }
-  
-# else
-
-  T* operator ->() {
-    assert (initialized());
-    return dataptr();
-  }
-  
-  constexpr T const& operator *() const {
-    return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), contained_val());
-  }
-  
-  T& operator *() {
-    assert (initialized());
-    return contained_val();
-  }
-  
-  constexpr T const& value() const {
-    return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
-  }
-  
-  T& value() {
-    return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
-  }
-  
-# endif
-  
-# if OPTIONAL_HAS_THIS_RVALUE_REFS == 1
-
-  template <class V>
-  constexpr T value_or(V&& v) const&
-  {
-    return *this ? **this : detail_::convert<T>(constexpr_forward<V>(v));
-  }
-  
-#   if OPTIONAL_HAS_MOVE_ACCESSORS == 1
-
-  template <class V>
-  OPTIONAL_MUTABLE_CONSTEXPR T value_or(V&& v) &&
-  {
-    return *this ? constexpr_move(const_cast<optional<T>&>(*this).contained_val()) : detail_::convert<T>(constexpr_forward<V>(v));
-  }
-
-#   else
- 
-  template <class V>
-  T value_or(V&& v) &&
-  {
-    return *this ? constexpr_move(const_cast<optional<T>&>(*this).contained_val()) : detail_::convert<T>(constexpr_forward<V>(v));
-  }
-  
-#   endif
-  
-# else
-  
-  template <class V>
-  constexpr T value_or(V&& v) const
-  {
-    return *this ? **this : detail_::convert<T>(constexpr_forward<V>(v));
-  }
-
-# endif
-
-};
-
-
-template <class T>
-class optional<T&>
-{
-  static_assert( !std::is_same<T, nullopt_t>::value, "bad T" );
-  static_assert( !std::is_same<T, in_place_t>::value, "bad T" );
-  T* ref;
-  
-public:
-
-  // 20.5.5.1, construction/destruction
-  constexpr optional() noexcept : ref(nullptr) {}
-  
-  constexpr optional(nullopt_t) noexcept : ref(nullptr) {}
-   
-  constexpr optional(T& v) noexcept : ref(detail_::static_addressof(v)) {}
-  
-  optional(T&&) = delete;
-  
-  constexpr optional(const optional& rhs) noexcept : ref(rhs.ref) {}
-  
-  explicit constexpr optional(in_place_t, T& v) noexcept : ref(detail_::static_addressof(v)) {}
-  
-  explicit optional(in_place_t, T&&) = delete;
-  
-  ~optional() = default;
-  
-  // 20.5.5.2, mutation
-  optional& operator=(nullopt_t) noexcept {
-    ref = nullptr;
-    return *this;
-  }
-  
-  // optional& operator=(const optional& rhs) noexcept {
-    // ref = rhs.ref;
-    // return *this;
-  // }
-  
-  // optional& operator=(optional&& rhs) noexcept {
-    // ref = rhs.ref;
-    // return *this;
-  // }
-  
-  template <typename U>
-  auto operator=(U&& rhs) noexcept
-  -> typename enable_if
-  <
-    is_same<typename decay<U>::type, optional<T&>>::value,
-    optional&
-  >::type
-  {
-    ref = rhs.ref;
-    return *this;
-  }
-  
-  template <typename U>
-  auto operator=(U&& rhs) noexcept
-  -> typename enable_if
-  <
-    !is_same<typename decay<U>::type, optional<T&>>::value,
-    optional&
-  >::type
-  = delete;
-  
-  void emplace(T& v) noexcept {
-    ref = detail_::static_addressof(v);
-  }
-  
-  void emplace(T&&) = delete;
-  
-  
-  void swap(optional<T&>& rhs) noexcept
-  {
-    std::swap(ref, rhs.ref);
-  }
-    
-  // 20.5.5.3, observers
-  constexpr T* operator->() const {
-    return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, ref);
-  }
-  
-  constexpr T& operator*() const {
-    return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, *ref);
-  }
-  
-  constexpr T& value() const {
-    return ref ? *ref : (throw bad_optional_access("bad optional access"), *ref);
-  }
-  
-  explicit constexpr operator bool() const noexcept {
-    return ref != nullptr;
-  }
-  constexpr bool has_value() const noexcept { return ref != nullptr; }
-
-  template <class V>
-  constexpr typename decay<T>::type value_or(V&& v) const
-  {
-    return *this ? **this : detail_::convert<typename decay<T>::type>(constexpr_forward<V>(v));
-  }
-};
-
-
-template <class T>
-class optional<T&&>
-{
-  static_assert( sizeof(T) == 0, "optional rvalue references disallowed" );
-};
-
-
-// 20.5.8, Relational operators
-template <class T> constexpr bool operator==(const optional<T>& x, const optional<T>& y)
-{
-  return bool(x) != bool(y) ? false : bool(x) == false ? true : *x == *y;
-}
-
-template <class T> constexpr bool operator!=(const optional<T>& x, const optional<T>& y)
-{
-  return !(x == y);
-}
-
-template <class T> constexpr bool operator<(const optional<T>& x, const optional<T>& y)
-{
-  return (!y) ? false : (!x) ? true : *x < *y;
-}
-
-template <class T> constexpr bool operator>(const optional<T>& x, const optional<T>& y)
-{
-  return (y < x);
-}
-
-template <class T> constexpr bool operator<=(const optional<T>& x, const optional<T>& y)
-{
-  return !(y < x);
-}
-
-template <class T> constexpr bool operator>=(const optional<T>& x, const optional<T>& y)
-{
-  return !(x < y);
-}
-
-
-// 20.5.9, Comparison with nullopt
-template <class T> constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept
-{
-  return (!x);
-}
-
-template <class T> constexpr bool operator==(nullopt_t, const optional<T>& x) noexcept
-{
-  return (!x);
-}
-
-template <class T> constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept
-{
-  return bool(x);
-}
-
-template <class T> constexpr bool operator!=(nullopt_t, const optional<T>& x) noexcept
-{
-  return bool(x);
-}
-
-template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept
-{
-  return false;
-}
-
-template <class T> constexpr bool operator<(nullopt_t, const optional<T>& x) noexcept
-{
-  return bool(x);
-}
-
-template <class T> constexpr bool operator<=(const optional<T>& x, nullopt_t) noexcept
-{
-  return (!x);
-}
-
-template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept
-{
-  return true;
-}
-
-template <class T> constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept
-{
-  return bool(x);
-}
-
-template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept
-{
-  return false;
-}
-
-template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept
-{
-  return true;
-}
-
-template <class T> constexpr bool operator>=(nullopt_t, const optional<T>& x) noexcept
-{
-  return (!x);
-}
-
-
-
-// 20.5.10, Comparison with T
-template <class T> constexpr bool operator==(const optional<T>& x, const T& v)
-{
-  return bool(x) ? *x == v : false;
-}
-
-template <class T> constexpr bool operator==(const T& v, const optional<T>& x)
-{
-  return bool(x) ? v == *x : false;
-}
-
-template <class T> constexpr bool operator!=(const optional<T>& x, const T& v)
-{
-  return bool(x) ? *x != v : true;
-}
-
-template <class T> constexpr bool operator!=(const T& v, const optional<T>& x)
-{
-  return bool(x) ? v != *x : true;
-}
-
-template <class T> constexpr bool operator<(const optional<T>& x, const T& v)
-{
-  return bool(x) ? *x < v : true;
-}
-
-template <class T> constexpr bool operator>(const T& v, const optional<T>& x)
-{
-  return bool(x) ? v > *x : true;
-}
-
-template <class T> constexpr bool operator>(const optional<T>& x, const T& v)
-{
-  return bool(x) ? *x > v : false;
-}
-
-template <class T> constexpr bool operator<(const T& v, const optional<T>& x)
-{
-  return bool(x) ? v < *x : false;
-}
-
-template <class T> constexpr bool operator>=(const optional<T>& x, const T& v)
-{
-  return bool(x) ? *x >= v : false;
-}
-
-template <class T> constexpr bool operator<=(const T& v, const optional<T>& x)
-{
-  return bool(x) ? v <= *x : false;
-}
-
-template <class T> constexpr bool operator<=(const optional<T>& x, const T& v)
-{
-  return bool(x) ? *x <= v : true;
-}
-
-template <class T> constexpr bool operator>=(const T& v, const optional<T>& x)
-{
-  return bool(x) ? v >= *x : true;
-}
-
-
-// Comparison of optional<T&> with T
-template <class T> constexpr bool operator==(const optional<T&>& x, const T& v)
-{
-  return bool(x) ? *x == v : false;
-}
-
-template <class T> constexpr bool operator==(const T& v, const optional<T&>& x)
-{
-  return bool(x) ? v == *x : false;
-}
-
-template <class T> constexpr bool operator!=(const optional<T&>& x, const T& v)
-{
-  return bool(x) ? *x != v : true;
-}
-
-template <class T> constexpr bool operator!=(const T& v, const optional<T&>& x)
-{
-  return bool(x) ? v != *x : true;
-}
-
-template <class T> constexpr bool operator<(const optional<T&>& x, const T& v)
-{
-  return bool(x) ? *x < v : true;
-}
-
-template <class T> constexpr bool operator>(const T& v, const optional<T&>& x)
-{
-  return bool(x) ? v > *x : true;
-}
-
-template <class T> constexpr bool operator>(const optional<T&>& x, const T& v)
-{
-  return bool(x) ? *x > v : false;
-}
-
-template <class T> constexpr bool operator<(const T& v, const optional<T&>& x)
-{
-  return bool(x) ? v < *x : false;
-}
-
-template <class T> constexpr bool operator>=(const optional<T&>& x, const T& v)
-{
-  return bool(x) ? *x >= v : false;
-}
-
-template <class T> constexpr bool operator<=(const T& v, const optional<T&>& x)
-{
-  return bool(x) ? v <= *x : false;
-}
-
-template <class T> constexpr bool operator<=(const optional<T&>& x, const T& v)
-{
-  return bool(x) ? *x <= v : true;
-}
-
-template <class T> constexpr bool operator>=(const T& v, const optional<T&>& x)
-{
-  return bool(x) ? v >= *x : true;
-}
-
-// Comparison of optional<T const&> with T
-template <class T> constexpr bool operator==(const optional<const T&>& x, const T& v)
-{
-  return bool(x) ? *x == v : false;
-}
-
-template <class T> constexpr bool operator==(const T& v, const optional<const T&>& x)
-{
-  return bool(x) ? v == *x : false;
-}
-
-template <class T> constexpr bool operator!=(const optional<const T&>& x, const T& v)
-{
-  return bool(x) ? *x != v : true;
-}
-
-template <class T> constexpr bool operator!=(const T& v, const optional<const T&>& x)
-{
-  return bool(x) ? v != *x : true;
-}
-
-template <class T> constexpr bool operator<(const optional<const T&>& x, const T& v)
-{
-  return bool(x) ? *x < v : true;
-}
-
-template <class T> constexpr bool operator>(const T& v, const optional<const T&>& x)
-{
-  return bool(x) ? v > *x : true;
-}
-
-template <class T> constexpr bool operator>(const optional<const T&>& x, const T& v)
-{
-  return bool(x) ? *x > v : false;
-}
-
-template <class T> constexpr bool operator<(const T& v, const optional<const T&>& x)
-{
-  return bool(x) ? v < *x : false;
-}
-
-template <class T> constexpr bool operator>=(const optional<const T&>& x, const T& v)
-{
-  return bool(x) ? *x >= v : false;
-}
-
-template <class T> constexpr bool operator<=(const T& v, const optional<const T&>& x)
-{
-  return bool(x) ? v <= *x : false;
-}
-
-template <class T> constexpr bool operator<=(const optional<const T&>& x, const T& v)
-{
-  return bool(x) ? *x <= v : true;
-}
-
-template <class T> constexpr bool operator>=(const T& v, const optional<const T&>& x)
-{
-  return bool(x) ? v >= *x : true;
-}
-
-
-// 20.5.12, Specialized algorithms
-template <class T>
-void swap(optional<T>& x, optional<T>& y) noexcept(noexcept(x.swap(y)))
-{
-  x.swap(y);
-}
-
-
-template <class T>
-constexpr optional<typename decay<T>::type> make_optional(T&& v)
-{
-  return optional<typename decay<T>::type>(constexpr_forward<T>(v));
-}
-
-template <class X>
-constexpr optional<X&> make_optional(reference_wrapper<X> v)
-{
-  return optional<X&>(v.get());
-}
-
-
-} // namespace experimental
-} // namespace std
-
-namespace std
-{
-  template <typename T>
-  struct hash<std::experimental::optional<T>>
-  {
-    typedef typename hash<T>::result_type result_type;
-    typedef std::experimental::optional<T> argument_type;
-    
-    constexpr result_type operator()(argument_type const& arg) const {
-      return arg ? std::hash<T>{}(*arg) : result_type{};
-    }
-  };
-  
-  template <typename T>
-  struct hash<std::experimental::optional<T&>>
-  {
-    typedef typename hash<T>::result_type result_type;
-    typedef std::experimental::optional<T&> argument_type;
-    
-    constexpr result_type operator()(argument_type const& arg) const {
-      return arg ? std::hash<T>{}(*arg) : result_type{};
-    }
-  };
-}
-
-# undef TR2_OPTIONAL_REQUIRES
-# undef TR2_OPTIONAL_ASSERTED_EXPRESSION
-
-# endif //___OPTIONAL_HPP___
diff --git a/src/libs/3rdparty/optional/test_optional.cpp b/src/libs/3rdparty/optional/test_optional.cpp
deleted file mode 100644
index 8ed356a562..0000000000
--- a/src/libs/3rdparty/optional/test_optional.cpp
+++ /dev/null
@@ -1,1459 +0,0 @@
-// Copyright (C) 2011 - 2012 Andrzej Krzemienski.
-//
-// Use, modification, and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// The idea and interface is based on Boost.Optional library
-// authored by Fernando Luis Cacciola Carballal
-
-# include "optional.hpp"
-# include <vector>
-# include <iostream>
-# include <functional>
-# include <complex>
-
-
-
-struct caller {
-    template <class T> caller(T fun) { fun(); }
-};
-# define CAT2(X, Y) X ## Y
-# define CAT(X, Y) CAT2(X, Y)
-# define TEST(NAME) caller CAT(__VAR, __LINE__) = []
-
-enum  State 
-{
-    sDefaultConstructed,
-    sValueCopyConstructed,
-    sValueMoveConstructed,
-    sCopyConstructed,
-    sMoveConstructed,
-    sMoveAssigned,
-    sCopyAssigned,
-    sValueCopyAssigned,
-    sValueMoveAssigned,
-    sMovedFrom,
-    sValueConstructed
-};
-
-struct OracleVal
-{
-    State s;
-    int i;
-    OracleVal(int i = 0) : s(sValueConstructed), i(i) {}
-};
-
-struct Oracle
-{
-    State s;
-    OracleVal val;
-
-    Oracle() : s(sDefaultConstructed) {}
-    Oracle(const OracleVal& v) : s(sValueCopyConstructed), val(v) {}
-    Oracle(OracleVal&& v) : s(sValueMoveConstructed), val(std::move(v)) {v.s = sMovedFrom;}
-    Oracle(const Oracle& o) : s(sCopyConstructed), val(o.val) {}
-    Oracle(Oracle&& o) : s(sMoveConstructed), val(std::move(o.val)) {o.s = sMovedFrom;}
-
-    Oracle& operator=(const OracleVal& v) { s = sValueCopyConstructed; val = v; return *this; }
-    Oracle& operator=(OracleVal&& v) { s = sValueMoveConstructed; val = std::move(v); v.s = sMovedFrom; return *this; }
-    Oracle& operator=(const Oracle& o) { s = sCopyConstructed; val = o.val; return *this; }
-    Oracle& operator=(Oracle&& o) { s = sMoveConstructed; val = std::move(o.val); o.s = sMovedFrom; return *this; }
-};
-
-struct Guard
-{
-    std::string val;
-    Guard() : val{} {}
-    explicit Guard(std::string s, int = 0) : val(s) {}
-    Guard(const Guard&) = delete;
-    Guard(Guard&&) = delete;
-    void operator=(const Guard&) = delete;
-    void operator=(Guard&&) = delete;
-};
-
-struct ExplicitStr
-{
-    std::string s;
-    explicit ExplicitStr(const char* chp) : s(chp) {};
-};
-
-struct Date
-{
-    int i;
-    Date() = delete;
-    Date(int i) : i{i} {};
-    Date(Date&& d) : i(d.i) { d.i = 0; }
-    Date(const Date&) = delete;
-    Date& operator=(const Date&) = delete;
-    Date& operator=(Date&& d) { i = d.i; d.i = 0; return *this;};
-};
-
-bool operator==( Oracle const& a, Oracle const& b ) { return a.val.i == b.val.i; }
-bool operator!=( Oracle const& a, Oracle const& b ) { return a.val.i != b.val.i; }
-
-
-namespace tr2 = std::experimental;
-
-
-TEST(disengaged_ctor)
-{
-    tr2::optional<int> o1;
-    assert (!o1);
-
-    tr2::optional<int> o2 = tr2::nullopt;
-    assert (!o2);
-
-    tr2::optional<int> o3 = o2;
-    assert (!o3);
-
-    assert (o1 == tr2::nullopt);
-    assert (o1 == tr2::optional<int>{});
-    assert (!o1);
-    assert (bool(o1) == false);
-
-    assert (o2 == tr2::nullopt);
-    assert (o2 == tr2::optional<int>{});
-    assert (!o2);
-    assert (bool(o2) == false);
-
-    assert (o3 == tr2::nullopt);
-    assert (o3 == tr2::optional<int>{});
-    assert (!o3);
-    assert (bool(o3) == false);
-
-    assert (o1 == o2);
-    assert (o2 == o1);
-    assert (o1 == o3);
-    assert (o3 == o1);
-    assert (o2 == o3);
-    assert (o3 == o2);
-};
-
-
-TEST(value_ctor)
-{
-  OracleVal v;
-  tr2::optional<Oracle> oo1(v);
-  assert (oo1 != tr2::nullopt);
-  assert (oo1 != tr2::optional<Oracle>{});
-  assert (oo1 == tr2::optional<Oracle>{v});
-  assert (!!oo1);
-  assert (bool(oo1));
-  // NA: assert (oo1->s == sValueCopyConstructed);
-  assert (oo1->s == sMoveConstructed);
-  assert (v.s == sValueConstructed);
-  
-  tr2::optional<Oracle> oo2(std::move(v));
-  assert (oo2 != tr2::nullopt);
-  assert (oo2 != tr2::optional<Oracle>{});
-  assert (oo2 == oo1);
-  assert (!!oo2);
-  assert (bool(oo2));
-  // NA: assert (oo2->s == sValueMoveConstructed);
-  assert (oo2->s == sMoveConstructed);
-  assert (v.s == sMovedFrom);
-
-  {
-      OracleVal v;
-      tr2::optional<Oracle> oo1{tr2::in_place, v};
-      assert (oo1 != tr2::nullopt);
-      assert (oo1 != tr2::optional<Oracle>{});
-      assert (oo1 == tr2::optional<Oracle>{v});
-      assert (!!oo1);
-      assert (bool(oo1));
-      assert (oo1->s == sValueCopyConstructed);
-      assert (v.s == sValueConstructed);
-
-      tr2::optional<Oracle> oo2{tr2::in_place, std::move(v)};
-      assert (oo2 != tr2::nullopt);
-      assert (oo2 != tr2::optional<Oracle>{});
-      assert (oo2 == oo1);
-      assert (!!oo2);
-      assert (bool(oo2));
-      assert (oo2->s == sValueMoveConstructed);
-      assert (v.s == sMovedFrom);
-  }
-};
-
-
-TEST(assignment)
-{
-    tr2::optional<int> oi;
-    oi = tr2::optional<int>{1};
-    assert (*oi == 1);
-
-    oi = tr2::nullopt;
-    assert (!oi);
-
-    oi = 2;
-    assert (*oi == 2);
-
-    oi = {};
-    assert (!oi);
-};
-
-
-template <class T>
-struct MoveAware
-{
-  T val;
-  bool moved;
-  MoveAware(T val) : val(val), moved(false) {}
-  MoveAware(MoveAware const&) = delete;
-  MoveAware(MoveAware&& rhs) : val(rhs.val), moved(rhs.moved) {
-    rhs.moved = true;
-  }
-  MoveAware& operator=(MoveAware const&) = delete;
-  MoveAware& operator=(MoveAware&& rhs) {
-    val = (rhs.val);
-    moved = (rhs.moved);
-    rhs.moved = true;
-    return *this;
-  }
-};
-
-TEST(moved_from_state)
-{
-  // first, test mock:
-  MoveAware<int> i{1}, j{2};
-  assert (i.val == 1);
-  assert (!i.moved);
-  assert (j.val == 2);
-  assert (!j.moved);
-  
-  MoveAware<int> k = std::move(i);
-  assert (k.val == 1);
-  assert (!k.moved);
-  assert (i.val == 1);
-  assert (i.moved);
-  
-  k = std::move(j);
-  assert (k.val == 2);
-  assert (!k.moved);
-  assert (j.val == 2);
-  assert (j.moved);
-  
-  // now, test optional
-  tr2::optional<MoveAware<int>> oi{1}, oj{2};
-  assert (oi);
-  assert (!oi->moved);
-  assert (oj);
-  assert (!oj->moved);
-  
-  tr2::optional<MoveAware<int>> ok = std::move(oi);
-  assert (ok);
-  assert (!ok->moved);
-  assert (oi);
-  assert (oi->moved);
-  
-  ok = std::move(oj);
-  assert (ok);
-  assert (!ok->moved);
-  assert (oj);
-  assert (oj->moved);
-};
-
-
-TEST(copy_move_ctor_optional_int)
-{
-  tr2::optional<int> oi;
-  tr2::optional<int> oj = oi;
-  
-  assert (!oj);
-  assert (oj == oi);
-  assert (oj == tr2::nullopt);
-  assert (!bool(oj));
-  
-  oi = 1;
-  tr2::optional<int> ok = oi;
-  assert (!!ok);
-  assert (bool(ok));
-  assert (ok == oi);
-  assert (ok != oj);
-  assert (*ok == 1);
-  
-  tr2::optional<int> ol = std::move(oi);
-  assert (!!ol);
-  assert (bool(ol));
-  assert (ol == oi);
-  assert (ol != oj);
-  assert (*ol == 1);
-};
-
-
-TEST(optional_optional)
-{
-  tr2::optional<tr2::optional<int>> oi1 = tr2::nullopt;
-  assert (oi1 == tr2::nullopt);
-  assert (!oi1);
-  
-  {
-  tr2::optional<tr2::optional<int>> oi2 {tr2::in_place};
-  assert (oi2 != tr2::nullopt);
-  assert (bool(oi2));
-  assert (*oi2 == tr2::nullopt);
-  //assert (!(*oi2));
-  //std::cout << typeid(**oi2).name() << std::endl;
-  }
-  
-  {
-  tr2::optional<tr2::optional<int>> oi2 {tr2::in_place, tr2::nullopt};
-  assert (oi2 != tr2::nullopt);
-  assert (bool(oi2));
-  assert (*oi2 == tr2::nullopt);
-  assert (!*oi2);
-  }
-  
-  {
-  tr2::optional<tr2::optional<int>> oi2 {tr2::optional<int>{}};
-  assert (oi2 != tr2::nullopt);
-  assert (bool(oi2));
-  assert (*oi2 == tr2::nullopt);
-  assert (!*oi2);
-  }
-  
-  tr2::optional<int> oi;
-  auto ooi = tr2::make_optional(oi);
-  static_assert( std::is_same<tr2::optional<tr2::optional<int>>, decltype(ooi)>::value, "");
-
-};
-
-TEST(example_guard)
-{
-  using namespace tr2;
-  //FAILS: optional<Guard> ogx(Guard("res1")); 
-  //FAILS: optional<Guard> ogx = "res1"; 
-  //FAILS: optional<Guard> ogx("res1"); 
-  optional<Guard> oga;                     // Guard is non-copyable (and non-moveable)     
-  optional<Guard> ogb(in_place, "res1");   // initialzes the contained value with "res1"  
-  assert (bool(ogb));
-  assert (ogb->val == "res1");
-            
-  optional<Guard> ogc(in_place);           // default-constructs the contained value
-  assert (bool(ogc));
-  assert (ogc->val == "");
-
-  oga.emplace("res1");                     // initialzes the contained value with "res1"  
-  assert (bool(oga));
-  assert (oga->val == "res1");
-  
-  oga.emplace();                           // destroys the contained value and 
-                                           // default-constructs the new one
-  assert (bool(oga));
-  assert (oga->val == "");
-  
-  oga = nullopt;                        // OK: make disengaged the optional Guard
-  assert (!(oga));
-  //FAILS: ogb = {};                          // ERROR: Guard is not Moveable
-};
-
-
-void process(){}
-void process(int ){}
-void processNil(){}
-
-
-TEST(example1)
-{
-  using namespace tr2;
-  optional<int> oi;                 // create disengaged object
-  optional<int> oj = nullopt;          // alternative syntax
-  oi = oj;                          // assign disengaged object
-  optional<int> ok = oj;            // ok is disengaged
-
-  if (oi)  assert(false);           // 'if oi is engaged...'
-  if (!oi) assert(true);            // 'if oi is disengaged...'
-
-  if (oi != nullopt) assert(false);    // 'if oi is engaged...'
-  if (oi == nullopt) assert(true);     // 'if oi is disengaged...'
-
-  assert(oi == ok);                 // two disengaged optionals compare equal
-  
-  ///////////////////////////////////////////////////////////////////////////
-  optional<int> ol{1};              // ol is engaged; its contained value is 1
-  ok = 2;                           // ok becomes engaged; its contained value is 2
-  oj = ol;                          // oj becomes engaged; its contained value is 1
-
-  assert(oi != ol);                 // disengaged != engaged
-  assert(ok != ol);                 // different contained values
-  assert(oj == ol);                 // same contained value
-  assert(oi < ol);                  // disengaged < engaged
-  assert(ol < ok);                  // less by contained value
-  
-  /////////////////////////////////////////////////////////////////////////////
-  optional<int> om{1};              // om is engaged; its contained value is 1
-  optional<int> on = om;            // on is engaged; its contained value is 1
-  om = 2;                           // om is engaged; its contained value is 2
-  assert (on != om);                // on still contains 3. They are not pointers
-
-  /////////////////////////////////////////////////////////////////////////////
-  int i = *ol;                      // i obtains the value contained in ol
-  assert (i == 1);
-  *ol = 9;                          // the object contained in ol becomes 9
-  assert(*ol == 9);
-  assert(ol == make_optional(9));  
-  
-  ///////////////////////////////////
-  int p = 1;
-  optional<int> op = p;
-  assert(*op == 1);
-  p = 2;                         
-  assert(*op == 1);                 // value contained in op is separated from p
-
-  ////////////////////////////////
-  if (ol)                      
-    process(*ol);                   // use contained value if present
-  else
-    process();                      // proceed without contained value
-    
-  if (!om)   
-    processNil();
-  else  
-    process(*om);   
-  
-  /////////////////////////////////////////
-  process(ol.value_or(0));     // use 0 if ol is disengaged
-  
-  ////////////////////////////////////////////
-  ok = nullopt;                         // if ok was engaged calls T's dtor
-  oj = {};                           // assigns a temporary disengaged optional
-};
-
-
-TEST(example_guard) 
-{
-  using std::experimental::optional;
-  const optional<int> c = 4; 
-  int i = *c;                        // i becomes 4
-  assert (i == 4);
-  // FAILS: *c = i;                            // ERROR: cannot assign to const int&
-};
-
-
-TEST(example_ref)
-{
-  using namespace std::experimental;
-  int i = 1;
-  int j = 2;
-  optional<int&> ora;                 // disengaged optional reference to int
-  optional<int&> orb = i;             // contained reference refers to object i
-
-  *orb = 3;                          // i becomes 3
-  // FAILS: ora = j;                           // ERROR: optional refs do not have assignment from T
-  // FAILS: ora = {j};                         // ERROR: optional refs do not have copy/move assignment
-  // FAILS: ora = orb;                         // ERROR: no copy/move assignment
-  ora.emplace(j);                    // OK: contained reference refers to object j
-  ora.emplace(i);                    // OK: contained reference now refers to object i
-
-  ora = nullopt;                        // OK: ora becomes disengaged
-};
-
-
-template <typename T>
-T getValue( tr2::optional<T> newVal = tr2::nullopt, tr2::optional<T&> storeHere = tr2::nullopt )
-{
-  T cached{};
-  
-  if (newVal) {
-    cached = *newVal;
-    
-    if (storeHere) {
-      *storeHere = *newVal; // LEGAL: assigning T to T
-    }      
-  }
-  return cached;      
-}
-
-TEST(example_optional_arg)
-{
-  int iii = 0;
-  iii = getValue<int>(iii, iii);
-  iii = getValue<int>(iii);
-  iii = getValue<int>();
-  
-  {
-    using namespace std::experimental;
-    optional<Guard> grd1{in_place, "res1", 1};   // guard 1 initialized
-    optional<Guard> grd2;
-
-    grd2.emplace("res2", 2);                     // guard 2 initialized
-    grd1 = nullopt;                                 // guard 1 released
-
-  }                                              // guard 2 released (in dtor)
-};
-
-
-std::tuple<Date, Date, Date> getStartMidEnd() { return std::tuple<Date, Date, Date>{Date{1}, Date{2}, Date{3}}; }
-void run(Date const&, Date const&, Date const&) {}
-
-TEST(example_date)
-{
-  using namespace std::experimental;
-  optional<Date> start, mid, end;           // Date doesn't have default ctor (no good default date)
-
-  std::tie(start, mid, end) = getStartMidEnd();
-  run(*start, *mid, *end); 
-};
-
-
-std::experimental::optional<char> readNextChar(){ return{}; }
-
-void run(std::experimental::optional<std::string>) {}
-void run(std::complex<double>) {}
-
-
-template <class T>
-void assign_norebind(tr2::optional<T&>& optref, T& obj)
-{
-  if (optref) *optref = obj;
-  else        optref.emplace(obj);
-}
-
-template <typename T> void unused(T&&) {}
-
-TEST(example_conceptual_model)
-{
-  using namespace std::experimental;
-  
-  optional<int> oi = 0;
-  optional<int> oj = 1;
-  optional<int> ok = nullopt;
-
-  oi = 1;
-  oj = nullopt;
-  ok = 0;
-
-  unused(oi == nullopt);
-  unused(oj == 0);
-  unused(ok == 1);
-};
-
-TEST(example_rationale)
-{
-  using namespace std::experimental;
-  if (optional<char> ch = readNextChar()) {
-    unused(ch);
-    // ...
-  }
-  
-  //////////////////////////////////
-  optional<int> opt1 = nullopt; 
-  optional<int> opt2 = {}; 
-
-  opt1 = nullopt;
-  opt2 = {};
-
-  if (opt1 == nullopt) {}
-  if (!opt2) {}
-  if (opt2 == optional<int>{}) {}
-  
-  
-  
-  ////////////////////////////////
-
-  run(nullopt);            // pick the second overload
-  // FAILS: run({});              // ambiguous
-
-  if (opt1 == nullopt) {} // fine
-  // FAILS: if (opt2 == {}) {}   // ilegal
-  
-  ////////////////////////////////
-  assert (optional<unsigned>{}  < optional<unsigned>{0});
-  assert (optional<unsigned>{0} < optional<unsigned>{1});
-  assert (!(optional<unsigned>{}  < optional<unsigned>{}) );
-  assert (!(optional<unsigned>{1} < optional<unsigned>{1}));
-
-  assert (optional<unsigned>{}  != optional<unsigned>{0});
-  assert (optional<unsigned>{0} != optional<unsigned>{1});
-  assert (optional<unsigned>{}  == optional<unsigned>{} );
-  assert (optional<unsigned>{0} == optional<unsigned>{0});
-  
-  /////////////////////////////////
-  optional<int> o;
-  o = make_optional(1);         // copy/move assignment
-  o = 1;           // assignment from T
-  o.emplace(1);    // emplacement 
-  
-  ////////////////////////////////////
-  int isas = 0, i = 9;
-  optional<int&> asas = i;
-  assign_norebind(asas, isas);
-  
-  /////////////////////////////////////
-  ////tr2::optional<std::vector<int>> ov2 = {2, 3};
-  ////assert (bool(ov2));
-  ////assert ((*ov2)[1] == 3);
-  ////
-  ////////////////////////////////
-  ////std::vector<int> v = {1, 2, 4, 8};
-  ////optional<std::vector<int>> ov = {1, 2, 4, 8};
-
-  ////assert (v == *ov);
-  ////
-  ////ov = {1, 2, 4, 8};
-
-  ////std::allocator<int> a;
-  ////optional<std::vector<int>> ou { in_place, {1, 2, 4, 8}, a };
-
-  ////assert (ou == ov);
-
-  //////////////////////////////
-  // inconvenient syntax:
-  {
-    
-      tr2::optional<std::vector<int>> ov2{tr2::in_place, {2, 3}};
-    
-      assert (bool(ov2));
-      assert ((*ov2)[1] == 3);
-  
-      ////////////////////////////
-
-      std::vector<int> v = {1, 2, 4, 8};
-      optional<std::vector<int>> ov{tr2::in_place, {1, 2, 4, 8}};
-
-      assert (v == *ov);
-  
-      ov.emplace({1, 2, 4, 8});
-/*
-      std::allocator<int> a;
-      optional<std::vector<int>> ou { in_place, {1, 2, 4, 8}, a };
-
-      assert (ou == ov);
-*/
-  }
-
-  /////////////////////////////////
-  {
-  typedef int T;
-  optional<optional<T>> ot {in_place};
-  optional<optional<T>> ou {in_place, nullopt};
-  optional<optional<T>> ov {optional<T>{}};
-  
-  optional<int> oi;
-  auto ooi = make_optional(oi);
-  static_assert( std::is_same<optional<optional<int>>, decltype(ooi)>::value, "");
-  }
-};
-
-
-bool fun(std::string , std::experimental::optional<int> oi = std::experimental::nullopt) 
-{
-  return bool(oi);
-}
-
-TEST(example_converting_ctor)
-{
-  using namespace std::experimental;
-  
-  assert (true == fun("dog", 2));
-  assert (false == fun("dog"));
-  assert (false == fun("dog", nullopt)); // just to be explicit
-};
-
-
-TEST(bad_comparison)
-{
-  tr2::optional<int> oi, oj;
-  int i;
-  bool b = (oi == oj);
-  b = (oi >= i);
-  b = (oi == i);
-  unused(b);
-};
-
-
-//// NOT APPLICABLE ANYMORE
-////TEST(perfect_ctor)
-////{
-////  //tr2::optional<std::string> ois = "OS";
-////  assert (*ois == "OS");
-////  
-////  // FAILS: tr2::optional<ExplicitStr> oes = "OS"; 
-////  tr2::optional<ExplicitStr> oes{"OS"};
-////  assert (oes->s == "OS");
-////};
-
-TEST(value_or)
-{
-  tr2::optional<int> oi = 1;
-  int i = oi.value_or(0);
-  assert (i == 1);
-  
-  oi = tr2::nullopt;
-  assert (oi.value_or(3) == 3);
-  
-  tr2::optional<std::string> os{"AAA"};
-  assert (os.value_or("BBB") == "AAA");
-  os = {};
-  assert (os.value_or("BBB") == "BBB");
-};
-
-TEST(mixed_order)
-{
-  using namespace std::experimental;
-  
-  optional<int> oN {nullopt};
-  optional<int> o0 {0};
-  optional<int> o1 {1};
-  
-  assert ( (oN <   0));
-  assert ( (oN <   1));
-  assert (!(o0 <   0));
-  assert ( (o0 <   1));
-  assert (!(o1 <   0));
-  assert (!(o1 <   1));
-  
-  assert (!(oN >=  0));
-  assert (!(oN >=  1));
-  assert ( (o0 >=  0));
-  assert (!(o0 >=  1));
-  assert ( (o1 >=  0));
-  assert ( (o1 >=  1));
-  
-  assert (!(oN >   0));
-  assert (!(oN >   1));
-  assert (!(o0 >   0));
-  assert (!(o0 >   1));
-  assert ( (o1 >   0));
-  assert (!(o1 >   1));
-  
-  assert ( (oN <=  0));
-  assert ( (oN <=  1));
-  assert ( (o0 <=  0));
-  assert ( (o0 <=  1));
-  assert (!(o1 <=  0));
-  assert ( (o1 <=  1));
-  
-  assert ( (0 >  oN));
-  assert ( (1 >  oN));
-  assert (!(0 >  o0));
-  assert ( (1 >  o0));
-  assert (!(0 >  o1));
-  assert (!(1 >  o1));
-  
-  assert (!(0 <= oN));
-  assert (!(1 <= oN));
-  assert ( (0 <= o0));
-  assert (!(1 <= o0));
-  assert ( (0 <= o1));
-  assert ( (1 <= o1));
-  
-  assert (!(0 <  oN));
-  assert (!(1 <  oN));
-  assert (!(0 <  o0));
-  assert (!(1 <  o0));
-  assert ( (0 <  o1));
-  assert (!(1 <  o1));
-  
-  assert ( (0 >= oN));
-  assert ( (1 >= oN));
-  assert ( (0 >= o0));
-  assert ( (1 >= o0));
-  assert (!(0 >= o1));
-  assert ( (1 >= o1));
-};
-
-struct BadRelops
-{
-  int i;
-};
-
-constexpr bool operator<(BadRelops a, BadRelops b) { return a.i < b.i; }
-constexpr bool operator>(BadRelops a, BadRelops b) { return a.i < b.i; } // intentional error!
-
-TEST(bad_relops)
-{
-  using namespace std::experimental;
-  BadRelops a{1}, b{2};
-  assert (a < b);
-  assert (a > b);
-  
-  optional<BadRelops> oa = a, ob = b;
-  assert (oa < ob);
-  assert (!(oa > ob));
-  
-  assert (oa < b);
-  assert (oa > b);
-  
-  optional<BadRelops&> ra = a, rb = b;
-  assert (ra < rb);
-  assert (!(ra > rb));
-  
-  assert (ra < b);
-  assert (ra > b);
-};
-
-
-TEST(mixed_equality)
-{
-  using namespace std::experimental;
-  
-  assert (make_optional(0) == 0);
-  assert (make_optional(1) == 1);
-  assert (make_optional(0) != 1);
-  assert (make_optional(1) != 0);
-  
-  optional<int> oN {nullopt};
-  optional<int> o0 {0};
-  optional<int> o1 {1};
-  
-  assert (o0 ==  0);
-  assert ( 0 == o0);
-  assert (o1 ==  1);
-  assert ( 1 == o1);
-  assert (o1 !=  0);
-  assert ( 0 != o1);
-  assert (o0 !=  1);
-  assert ( 1 != o0);
-  
-  assert ( 1 != oN);
-  assert ( 0 != oN);
-  assert (oN !=  1);
-  assert (oN !=  0);
-  assert (!( 1 == oN));
-  assert (!( 0 == oN));
-  assert (!(oN ==  1));
-  assert (!(oN ==  0));
-  
-  std::string cat{"cat"}, dog{"dog"};
-  optional<std::string> oNil{}, oDog{"dog"}, oCat{"cat"};
-  
-  assert (oCat ==  cat);
-  assert ( cat == oCat);
-  assert (oDog ==  dog);
-  assert ( dog == oDog);
-  assert (oDog !=  cat);
-  assert ( cat != oDog);
-  assert (oCat !=  dog);
-  assert ( dog != oCat);
-  
-  assert ( dog != oNil);
-  assert ( cat != oNil);
-  assert (oNil !=  dog);
-  assert (oNil !=  cat);
-  assert (!( dog == oNil));
-  assert (!( cat == oNil));
-  assert (!(oNil ==  dog));
-  assert (!(oNil ==  cat));
-};
-
-TEST(const_propagation)
-{
-  using namespace std::experimental;
-  
-  optional<int> mmi{0};
-  static_assert(std::is_same<decltype(*mmi), int&>::value, "WTF");
-  
-  const optional<int> cmi{0};
-  static_assert(std::is_same<decltype(*cmi), const int&>::value, "WTF");
-  
-  optional<const int> mci{0};
-  static_assert(std::is_same<decltype(*mci), const int&>::value, "WTF");
-  
-  optional<const int> cci{0};
-  static_assert(std::is_same<decltype(*cci), const int&>::value, "WTF");
-};
-
-
-static_assert(std::is_base_of<std::logic_error, std::experimental::bad_optional_access>::value, "");
-
-TEST(safe_value)
-{
-  using namespace std::experimental;
-  
-  try {
-    optional<int> ovN{}, ov1{1};
-    
-    int& r1 = ov1.value();
-    assert (r1 == 1);
-    
-    try { 
-      ovN.value();
-      assert (false);
-    }
-    catch (bad_optional_access const&) {
-    }
-    
-    { // ref variant
-      int i1 = 1;
-      optional<int&> orN{}, or1{i1};
-      
-      int& r2 = or1.value();
-      assert (r2 == 1);
-      
-      try { 
-        orN.value();
-        assert (false);
-      }
-      catch (bad_optional_access const&) {
-      }
-    }
-  }  
-  catch(...) {
-    assert (false);
-  }
-};
-
-TEST(optional_ref)
-{
-  using namespace tr2;
-  // FAILS: optional<int&&> orr;
-  // FAILS: optional<nullopt_t&> on;
-  int i = 8;
-  optional<int&> ori;
-  assert (!ori);
-  ori.emplace(i);
-  assert (bool(ori));
-  assert (*ori == 8);
-  assert (&*ori == &i);
-  *ori = 9;
-  assert (i == 9);
-  
-  // FAILS: int& ir = ori.value_or(i);
-  int ii = ori.value_or(i);
-  assert (ii == 9);
-  ii = 7;
-  assert (*ori == 9);
-  
-  int j = 22;
-  auto&& oj = make_optional(std::ref(j));
-  *oj = 23;
-  assert (&*oj == &j);
-  assert (j == 23);
-};
-
-TEST(optional_ref_const_propagation)
-{
-  using namespace std::experimental;
-  
-  int i = 9;
-  const optional<int&> mi = i;
-  int& r = *mi; 
-  optional<const int&> ci = i;
-  static_assert(std::is_same<decltype(*mi), int&>::value, "WTF");
-  static_assert(std::is_same<decltype(*ci), const int&>::value, "WTF");
-  
-  unused(r);
-};
-
-TEST(optional_ref_assign)
-{
-  using namespace std::experimental;
-  
-  int i = 9;
-  optional<int&> ori = i;
-  
-  int j = 1;
-  ori = optional<int&>{j};
-  ori = {j};
-  // FAILS: ori = j;
-  
-  optional<int&> orx = ori;
-  ori = orx;
-  
-  optional<int&> orj = j;
-  
-  assert (ori);
-  assert (*ori == 1);
-  assert (ori == orj);
-  assert (i == 9);
-  
-  *ori = 2;
-  assert (*ori == 2);
-  assert (ori == 2);
-  assert (2 == ori);
-  assert (ori != 3);
-  
-  assert (ori == orj);
-  assert (j == 2);
-  assert (i == 9);
-  
-  ori = {};
-  assert (!ori);
-  assert (ori != orj);
-  assert (j == 2);
-  assert (i == 9);
-};
-
-
-TEST(optional_ref_swap)
-{
-  using namespace std::experimental;
-  int i = 0;
-  int j = 1;
-  optional<int&> oi = i;
-  optional<int&> oj = j;
-  
-  assert (&*oi == &i);
-  assert (&*oj == &j);
-  
-  swap(oi, oj);
-  assert (&*oi == &j);
-  assert (&*oj == &i);
-};
-
-TEST(optional_initialization)
-{
-    using namespace tr2;
-    using std::string;
-    string s = "STR";
-
-    optional<string> os{s};
-    optional<string> ot = s;
-    optional<string> ou{"STR"};
-    optional<string> ov = string{"STR"};
-    
-};
-
-#include <unordered_set>
-
-TEST(optional_hashing)
-{
-    using namespace tr2;
-    using std::string;
-    
-    std::hash<int> hi;
-    std::hash<optional<int>> hoi;
-    std::hash<string> hs;
-    std::hash<optional<string>> hos;
-    
-    assert (hi(0) == hoi(optional<int>{0}));
-    assert (hi(1) == hoi(optional<int>{1}));
-    assert (hi(3198) == hoi(optional<int>{3198}));
-    
-    assert (hs("") == hos(optional<string>{""}));
-    assert (hs("0") == hos(optional<string>{"0"}));
-    assert (hs("Qa1#") == hos(optional<string>{"Qa1#"}));
-    
-    std::unordered_set<optional<string>> set;
-    assert(set.find({"Qa1#"}) == set.end());
-    
-    set.insert({"0"});
-    assert(set.find({"Qa1#"}) == set.end());
-    
-    set.insert({"Qa1#"});
-    assert(set.find({"Qa1#"}) != set.end());
-};
-
-
-// optional_ref_emulation
-template <class T>
-struct generic
-{
-  typedef T type;
-};
-
-template <class U>
-struct generic<U&>
-{
-  typedef std::reference_wrapper<U> type;
-};
-
-template <class T>
-using Generic = typename generic<T>::type;
-
-template <class X>
-bool generic_fun()
-{
-  std::experimental::optional<Generic<X>> op;
-  return bool(op);
-}
-
-TEST(optional_ref_emulation)
-{
-  using namespace std::experimental;
-  optional<Generic<int>> oi = 1;
-  assert (*oi == 1);
-  
-  int i = 8;
-  int j = 4;
-  optional<Generic<int&>> ori {i};
-  assert (*ori == 8);
-  assert ((void*)&*ori != (void*)&i); // !DIFFERENT THAN optional<T&>
-
-  *ori = j;
-  assert (*ori == 4);
-};
-
-
-# if OPTIONAL_HAS_THIS_RVALUE_REFS == 1
-TEST(moved_on_value_or)
-{
-  using namespace tr2;
-  optional<Oracle> oo{in_place};
-  
-  assert (oo);
-  assert (oo->s == sDefaultConstructed);
-  
-  Oracle o = std::move(oo).value_or( Oracle{OracleVal{}} );
-  assert (oo);
-  assert (oo->s == sMovedFrom);
-  assert (o.s == sMoveConstructed);
-  
-  optional<MoveAware<int>> om {in_place, 1};
-  assert (om);
-  assert (om->moved == false);
-  
-  /*MoveAware<int> m =*/ std::move(om).value_or( MoveAware<int>{1} );
-  assert (om);
-  assert (om->moved == true);
-
-# if OPTIONAL_HAS_MOVE_ACCESSORS == 1  
-  {
-    Date d = optional<Date>{in_place, 1}.value();
-    assert (d.i); // to silence compiler warning
-	
-	Date d2 = *optional<Date>{in_place, 1};
-    assert (d2.i); // to silence compiler warning
-  }
-# endif
-};
-# endif
-
-
-TEST(optional_ref_hashing)
-{
-    using namespace tr2;
-    using std::string;
-    
-    std::hash<int> hi;
-    std::hash<optional<int&>> hoi;
-    std::hash<string> hs;
-    std::hash<optional<string&>> hos;
-    
-    int i0 = 0;
-    int i1 = 1;
-    assert (hi(0) == hoi(optional<int&>{i0}));
-    assert (hi(1) == hoi(optional<int&>{i1}));
-    
-    string s{""};
-    string s0{"0"};
-    string sCAT{"CAT"};
-    assert (hs("") == hos(optional<string&>{s}));
-    assert (hs("0") == hos(optional<string&>{s0}));
-    assert (hs("CAT") == hos(optional<string&>{sCAT}));
-    
-    std::unordered_set<optional<string&>> set;
-    assert(set.find({sCAT}) == set.end());
-    
-    set.insert({s0});
-    assert(set.find({sCAT}) == set.end());
-    
-    set.insert({sCAT});
-    assert(set.find({sCAT}) != set.end());
-};
-
-struct Combined
-{
-  int m = 0;
-  int n = 1;
-  
-  constexpr Combined() : m{5}, n{6} {}
-  constexpr Combined(int m, int n) : m{m}, n{n} {}
-};
-
-struct Nasty
-{
-  int m = 0;
-  int n = 1;
-  
-  constexpr Nasty() : m{5}, n{6} {}
-  constexpr Nasty(int m, int n) : m{m}, n{n} {}
-  
-  int operator&() { return n; }
-  int operator&() const { return n; }
-};
-
-TEST(arrow_operator)
-{
-  using namespace std::experimental;
-  
-  optional<Combined> oc1{in_place, 1, 2};
-  assert (oc1);
-  assert (oc1->m == 1);
-  assert (oc1->n == 2);
-  
-  optional<Nasty> on{in_place, 1, 2};
-  assert (on);
-  assert (on->m == 1);
-  assert (on->n == 2);
-};
-
-TEST(arrow_wit_optional_ref)
-{
-  using namespace std::experimental;
-  
-  Combined c{1, 2};
-  optional<Combined&> oc = c;
-  assert (oc);
-  assert (oc->m == 1);
-  assert (oc->n == 2);
-  
-  Nasty n{1, 2};
-  Nasty m{3, 4};
-  Nasty p{5, 6};
-  
-  optional<Nasty&> on{n};
-  assert (on);
-  assert (on->m == 1);
-  assert (on->n == 2);
-  
-  on = {m};
-  assert (on);
-  assert (on->m == 3);
-  assert (on->n == 4);
-  
-  on.emplace(p);
-  assert (on);
-  assert (on->m == 5);
-  assert (on->n == 6);
-  
-  optional<Nasty&> om{in_place, n};
-  assert (om);
-  assert (om->m == 1);
-  assert (om->n == 2);
-};
-
-TEST(no_dangling_reference_in_value)
-{
-  // this mostly tests compiler warnings
-  using namespace std::experimental;
-  optional<int> oi {2};
-  unused (oi.value());
-  const optional<int> coi {3};
-  unused (coi.value());
-};
-
-struct CountedObject
-{
-  static int _counter;
-  bool _throw;
-  CountedObject(bool b) : _throw(b) { ++_counter; }
-  CountedObject(CountedObject const& rhs) : _throw(rhs._throw) { if (_throw) throw int(); }
-  ~CountedObject() { --_counter; }
-};
-
-int CountedObject::_counter = 0;
-
-TEST(exception_safety)
-{
-  using namespace std::experimental;
-  try {
-    optional<CountedObject> oo(in_place, true); // throw
-    optional<CountedObject> o1(oo);
-  }
-  catch(...)
-  {
-    //
-  }
-  assert(CountedObject::_counter == 0);
-  
-  try {
-    optional<CountedObject> oo(in_place, true); // throw
-    optional<CountedObject> o1(std::move(oo));  // now move
-  }
-  catch(...)
-  {
-    //
-  }
-  assert(CountedObject::_counter == 0);
-};
-
-//// constexpr tests
-
-// these 4 classes have different noexcept signatures in move operations
-struct NothrowBoth {
-  NothrowBoth(NothrowBoth&&) noexcept(true) {};
-  void operator=(NothrowBoth&&) noexcept(true) {};
-};
-struct NothrowCtor {
-  NothrowCtor(NothrowCtor&&) noexcept(true) {};
-  void operator=(NothrowCtor&&) noexcept(false) {};
-};
-struct NothrowAssign {
-  NothrowAssign(NothrowAssign&&) noexcept(false) {};
-  void operator=(NothrowAssign&&) noexcept(true) {};
-};
-struct NothrowNone {
-  NothrowNone(NothrowNone&&) noexcept(false) {};
-  void operator=(NothrowNone&&) noexcept(false) {};
-};
-
-void test_noexcept()
-{
-  {
-    tr2::optional<NothrowBoth> b1, b2;
-    static_assert(noexcept(tr2::optional<NothrowBoth>{tr2::constexpr_move(b1)}), "bad noexcept!");
-    static_assert(noexcept(b1 = tr2::constexpr_move(b2)), "bad noexcept!");
-  }
-  {
-    tr2::optional<NothrowCtor> c1, c2;
-    static_assert(noexcept(tr2::optional<NothrowCtor>{tr2::constexpr_move(c1)}), "bad noexcept!");
-    static_assert(!noexcept(c1 = tr2::constexpr_move(c2)), "bad noexcept!");
-  }
-  {
-    tr2::optional<NothrowAssign> a1, a2;
-    static_assert(!noexcept(tr2::optional<NothrowAssign>{tr2::constexpr_move(a1)}), "bad noexcept!");
-    static_assert(!noexcept(a1 = tr2::constexpr_move(a2)), "bad noexcept!");
-  }
-  {
-    tr2::optional<NothrowNone> n1, n2;
-    static_assert(!noexcept(tr2::optional<NothrowNone>{tr2::constexpr_move(n1)}), "bad noexcept!");
-    static_assert(!noexcept(n1 = tr2::constexpr_move(n2)), "bad noexcept!");
-  }
-}
-
-
-void constexpr_test_disengaged()
-{
-  constexpr tr2::optional<int> g0{};
-  constexpr tr2::optional<int> g1{tr2::nullopt};
-  static_assert( !g0, "initialized!" );
-  static_assert( !g1, "initialized!" );
-  
-  static_assert( bool(g1) == bool(g0), "ne!" );
-  
-  static_assert( g1 == g0, "ne!" );
-  static_assert( !(g1 != g0), "ne!" );
-  static_assert( g1 >= g0, "ne!" );
-  static_assert( !(g1 > g0), "ne!" );
-  static_assert( g1 <= g0, "ne!" );
-  static_assert( !(g1 <g0), "ne!" );
-  
-  static_assert( g1 == tr2::nullopt, "!" );
-  static_assert( !(g1 != tr2::nullopt), "!" );
-  static_assert( g1 <= tr2::nullopt, "!" );
-  static_assert( !(g1 < tr2::nullopt), "!" );
-  static_assert( g1 >= tr2::nullopt, "!" );
-  static_assert( !(g1 > tr2::nullopt), "!" );
-  
-  static_assert(  (tr2::nullopt == g0), "!" );
-  static_assert( !(tr2::nullopt != g0), "!" );
-  static_assert(  (tr2::nullopt >= g0), "!" );
-  static_assert( !(tr2::nullopt >  g0), "!" );
-  static_assert(  (tr2::nullopt <= g0), "!" );
-  static_assert( !(tr2::nullopt <  g0), "!" );
-  
-  static_assert(  (g1 != tr2::optional<int>(1)), "!" );
-  static_assert( !(g1 == tr2::optional<int>(1)), "!" );
-  static_assert(  (g1 <  tr2::optional<int>(1)), "!" );
-  static_assert(  (g1 <= tr2::optional<int>(1)), "!" );
-  static_assert( !(g1 >  tr2::optional<int>(1)), "!" );
-  static_assert( !(g1 >  tr2::optional<int>(1)), "!" );
-}
-
-
-constexpr tr2::optional<int> g0{};
-constexpr tr2::optional<int> g2{2};
-static_assert( g2, "not initialized!" );
-static_assert( *g2 == 2, "not 2!" );
-static_assert( g2 == tr2::optional<int>(2), "not 2!" );
-static_assert( g2 != g0, "eq!" );
-
-# if OPTIONAL_HAS_MOVE_ACCESSORS == 1
-static_assert( *tr2::optional<int>{3} == 3, "WTF!" );
-static_assert( tr2::optional<int>{3}.value() == 3, "WTF!" );
-static_assert( tr2::optional<int>{3}.value_or(1) == 3, "WTF!" );
-static_assert( tr2::optional<int>{}.value_or(4) == 4, "WTF!" );
-# endif
-
-constexpr tr2::optional<Combined> gc0{tr2::in_place};
-static_assert(gc0->n == 6, "WTF!");
-
-// optional refs
-int gi = 0;
-constexpr tr2::optional<int&> gori = gi;
-constexpr tr2::optional<int&> gorn{};
-constexpr int& gri = *gori;
-static_assert(gori, "WTF");
-static_assert(!gorn, "WTF");
-static_assert(gori != tr2::nullopt, "WTF");
-static_assert(gorn == tr2::nullopt, "WTF");
-static_assert(&gri == &*gori, "WTF");
-
-constexpr int gci = 1;
-constexpr tr2::optional<int const&> gorci = gci;
-constexpr tr2::optional<int const&> gorcn{};
-
-static_assert(gorcn <  gorci, "WTF");
-static_assert(gorcn <= gorci, "WTF");
-static_assert(gorci == gorci, "WTF");
-static_assert(*gorci == 1, "WTF");
-static_assert(gorci == gci, "WTF");
-
-namespace constexpr_optional_ref_and_arrow 
-{
-  using namespace std::experimental;
-  constexpr Combined c{1, 2};
-  constexpr optional<Combined const&> oc = c;
-  static_assert(oc, "WTF!");
-  static_assert(oc->m == 1, "WTF!");
-  static_assert(oc->n == 2, "WTF!");
-}
-
-#if OPTIONAL_HAS_CONSTEXPR_INIT_LIST
-
-namespace InitList
-{
-  using namespace std::experimental;
-  
-  struct ConstInitLister
-  {
-    template <typename T>
-	constexpr ConstInitLister(std::initializer_list<T> il) : len (il.size()) {}
-    size_t len;
-  };
-  
-  constexpr ConstInitLister CIL {2, 3, 4};
-  static_assert(CIL.len == 3, "WTF!");
-  
-  constexpr optional<ConstInitLister> oil {in_place, {4, 5, 6, 7}};
-  static_assert(oil, "WTF!");
-  static_assert(oil->len == 4, "WTF!");
-}
-
-#endif // OPTIONAL_HAS_CONSTEXPR_INIT_LIST
-
-// end constexpr tests
-
-
-#include <string>
-
-
-struct VEC
-{
-    std::vector<int> v;
-    template <typename... X>
-    VEC( X&&...x) : v(std::forward<X>(x)...) {}
-
-    template <typename U, typename... X>
-    VEC(std::initializer_list<U> il, X&&...x) : v(il, std::forward<X>(x)...) {}
-};
-
-
-
-int main() {
-  tr2::optional<int> oi = 1;
-  assert (bool(oi));
-  oi.operator=({});
-  assert (!oi);
-
-  VEC v = {5, 6};
-
-  if (OPTIONAL_HAS_THIS_RVALUE_REFS)
-    std::cout << "Optional has rvalue references for *this" << std::endl;
-  else
-    std::cout << "Optional doesn't have rvalue references for *this" << std::endl;
-	
-  if (OPTIONAL_HAS_CONSTEXPR_INIT_LIST)
-    std::cout << "Optional has constexpr initializer_list" << std::endl;
-  else
-    std::cout << "Optional doesn't have constexpr initializer_list" << std::endl;
-
-  if (OPTIONAL_HAS_MOVE_ACCESSORS)
-    std::cout << "Optional has constexpr move accessors" << std::endl;
-  else
-    std::cout << "Optional doesn't have constexpr move accessors" << std::endl;	
-}
-
diff --git a/src/libs/3rdparty/optional/test_type_traits.cpp b/src/libs/3rdparty/optional/test_type_traits.cpp
deleted file mode 100644
index 8ec82b7087..0000000000
--- a/src/libs/3rdparty/optional/test_type_traits.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright (C) 2011 - 2012 Andrzej Krzemienski.
-//
-// Use, modification, and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-#if (defined __clang__)
-  namespace std { class type_info; }
-#endif
-
-# include "optional.hpp"
-
-namespace std { namespace experimental {
-
-struct Val
-{
-  Val(){}
-  Val( Val const & ){}
-  Val( Val && ) noexcept {}
-  
-  Val & operator=( Val const & ) = delete;
-  Val & operator=( Val && ) noexcept = delete;
-};
-
-struct Safe
-{
-  Safe(){}
-  Safe( Safe const & ){}
-  Safe( Safe && ) noexcept {}
-    
-  Safe & operator=( Safe const & ){ return *this; }
-  Safe & operator=( Safe && ) noexcept { return *this; }
-};
-
-struct Unsafe
-{
-  Unsafe(){}
-  Unsafe( Unsafe const & ){}
-  Unsafe( Unsafe && ){}
-    
-  Unsafe & operator=( Unsafe const & ){ return *this; }
-  Unsafe & operator=( Unsafe && ) { return *this; }
-};
-
-struct VoidNothrowBoth
-{
-  VoidNothrowBoth(VoidNothrowBoth&&) noexcept(true) {};
-  void operator=(VoidNothrowBoth&&) noexcept(true) {}; // note void return type
-};
-
-
-static_assert(is_nothrow_move_constructible<Safe>::value, "WTF!");
-static_assert(!is_nothrow_move_constructible<Unsafe>::value, "WTF!");
-
-static_assert(is_assignable<Safe&, Safe&&>::value, "WTF!");
-static_assert(!is_assignable<Val&, Val&&>::value, "WTF!");
-
-static_assert(is_nothrow_move_assignable<Safe>::value, "WTF!");
-static_assert(!is_nothrow_move_assignable<Unsafe>::value, "WTF!");
-
-static_assert(is_nothrow_move_constructible<VoidNothrowBoth>::value, "WTF!");
-static_assert(is_nothrow_move_assignable<VoidNothrowBoth>::value, "WTF!");
-
-}} // namespace std::experimental
-
-int main() { }
diff --git a/src/libs/cplusplus/FindUsages.cpp b/src/libs/cplusplus/FindUsages.cpp
index 2ac49872c1..2f52079bdc 100644
--- a/src/libs/cplusplus/FindUsages.cpp
+++ b/src/libs/cplusplus/FindUsages.cpp
@@ -16,10 +16,9 @@
 #include <cplusplus/TranslationUnit.h>
 #include <cplusplus/TypeOfExpression.h>
 
-#include <utils/optional.h>
-
 #include <QDebug>
 
+#include <optional>
 
 using namespace CPlusPlus;
 
@@ -189,8 +188,8 @@ public:
             if (const auto binExpr = (*it)->asBinaryExpression()) {
                 if (binExpr->left_expression == *(it - 1) && isAssignment(binExpr->binary_op_token))
                     return checkPotentialWrite(Usage::Type::Write, it + 1);
-                const Utils::optional<LookupItem> item = getTypeOfExpr(binExpr->left_expression,
-                                                                       it + 1);
+                const std::optional<LookupItem> item = getTypeOfExpr(binExpr->left_expression,
+                                                                     it + 1);
                 if (!item)
                     return Usage::Type::Other;
                 return checkPotentialWrite(getUsageTypeFromLhsAndRhs(
@@ -349,12 +348,12 @@ private:
         return m_findUsages->typeofExpression(expr, m_findUsages->_doc, scope);
     }
 
-    Utils::optional<LookupItem> getTypeOfExpr(ExpressionAST *expr, Iterator scopeSearchPos) const
+    std::optional<LookupItem> getTypeOfExpr(ExpressionAST *expr, Iterator scopeSearchPos) const
     {
         const QList<LookupItem> items = getTypesOfExpr(expr, scopeSearchPos);
         if (items.isEmpty())
             return {};
-        return Utils::optional<LookupItem>(items.first());
+        return std::optional<LookupItem>(items.first());
     }
 
     Usage::Type getUsageTypeFromLhsAndRhs(const FullySpecifiedType &lhsType, ExpressionAST *rhs,
@@ -365,7 +364,7 @@ private:
             return usageType;
 
         // If the lhs has type auto, we use the RHS type.
-        const Utils::optional<LookupItem> item = getTypeOfExpr(rhs, scopeSearchPos);
+        const std::optional<LookupItem> item = getTypeOfExpr(rhs, scopeSearchPos);
         if (!item)
             return Usage::Type::Other;
         return getUsageTypeFromDataType(item->type());
@@ -385,8 +384,8 @@ private:
                     continue;
                 if (memberAccess->member_name == *(it - 1))
                     return Usage::Type::Other;
-                const Utils::optional<LookupItem> item
-                        = getTypeOfExpr(memberAccess->base_expression, it);
+                const std::optional<LookupItem> item = getTypeOfExpr(memberAccess->base_expression,
+                                                                     it);
                 if (!item)
                     return Usage::Type::Other;
                 FullySpecifiedType baseExprType = item->type();
diff --git a/src/libs/cplusplus/MatchingText.cpp b/src/libs/cplusplus/MatchingText.cpp
index 2031b35336..bbd0e8d30a 100644
--- a/src/libs/cplusplus/MatchingText.cpp
+++ b/src/libs/cplusplus/MatchingText.cpp
@@ -13,7 +13,8 @@
 #include <QDebug>
 
 #include <utils/algorithm.h>
-#include <utils/optional.h>
+
+#include <optional>
 
 using namespace CPlusPlus;
 
@@ -157,7 +158,7 @@ static bool isCursorAtEndOfLineButMaybeBeforeComment(const QTextCursor &cursor)
     return Utils::allOf(tokens, [](const Token &token) { return token.isComment(); });
 }
 
-using TokenIndexResult = Utils::optional<int>;
+using TokenIndexResult = std::optional<int>;
 
 // 10.6.1 Attribute syntax and semantics
 // This does not handle alignas() since it is not needed for the namespace case.
diff --git a/src/libs/extensionsystem/pluginmanager.cpp b/src/libs/extensionsystem/pluginmanager.cpp
index 66aff60936..4ff50a12c5 100644
--- a/src/libs/extensionsystem/pluginmanager.cpp
+++ b/src/libs/extensionsystem/pluginmanager.cpp
@@ -1467,7 +1467,7 @@ public:
                + ".lock";
     }
 
-    static Utils::optional<QString> lockedPluginName(PluginManagerPrivate *pm)
+    static std::optional<QString> lockedPluginName(PluginManagerPrivate *pm)
     {
         const QString lockFilePath = LockFile::filePath(pm);
         if (QFile::exists(lockFilePath)) {
@@ -1507,7 +1507,7 @@ void PluginManagerPrivate::checkForProblematicPlugins()
 {
     if (!enableCrashCheck)
         return;
-    const Utils::optional<QString> pluginName = LockFile::lockedPluginName(this);
+    const std::optional<QString> pluginName = LockFile::lockedPluginName(this);
     if (pluginName) {
         PluginSpec *spec = pluginByName(*pluginName);
         if (spec && !spec->isRequired()) {
diff --git a/src/libs/extensionsystem/pluginspec_p.h b/src/libs/extensionsystem/pluginspec_p.h
index affe0b5ca9..fd7ff0de1c 100644
--- a/src/libs/extensionsystem/pluginspec_p.h
+++ b/src/libs/extensionsystem/pluginspec_p.h
@@ -6,8 +6,6 @@
 #include "pluginspec.h"
 #include "iplugin.h"
 
-#include <utils/optional.h>
-
 #include <QJsonObject>
 #include <QObject>
 #include <QPluginLoader>
@@ -16,6 +14,8 @@
 #include <QVector>
 #include <QXmlStreamReader>
 
+#include <optional>
+
 namespace ExtensionSystem {
 
 class IPlugin;
@@ -47,8 +47,8 @@ public:
     void setForceEnabled(bool value);
     void setForceDisabled(bool value);
 
-    Utils::optional<QPluginLoader> loader;
-    Utils::optional<QStaticPlugin> staticPlugin;
+    std::optional<QPluginLoader> loader;
+    std::optional<QStaticPlugin> staticPlugin;
 
     QString name;
     QString version;
diff --git a/src/libs/languageserverprotocol/clientcapabilities.cpp b/src/libs/languageserverprotocol/clientcapabilities.cpp
index f92103cf35..b7c5c606bd 100644
--- a/src/libs/languageserverprotocol/clientcapabilities.cpp
+++ b/src/libs/languageserverprotocol/clientcapabilities.cpp
@@ -5,14 +5,13 @@
 
 namespace LanguageServerProtocol {
 
-Utils::optional<QList<SymbolKind> > SymbolCapabilities::SymbolKindCapabilities::valueSet() const
+std::optional<QList<SymbolKind>> SymbolCapabilities::SymbolKindCapabilities::valueSet() const
 {
-    if (Utils::optional<QList<int>> array = optionalArray<int>(valueSetKey)) {
-        return Utils::make_optional(Utils::transform(*array, [] (int value) {
-            return static_cast<SymbolKind>(value);
-        }));
+    if (std::optional<QList<int>> array = optionalArray<int>(valueSetKey)) {
+        return std::make_optional(
+            Utils::transform(*array, [](int value) { return static_cast<SymbolKind>(value); }));
     }
-    return Utils::nullopt;
+    return std::nullopt;
 }
 
 void SymbolCapabilities::SymbolKindCapabilities::setValueSet(const QList<SymbolKind> &valueSet)
@@ -25,7 +24,7 @@ WorkspaceClientCapabilities::WorkspaceClientCapabilities()
     setWorkspaceFolders(true);
 }
 
-Utils::optional<std::variant<bool, QJsonObject>> SemanticTokensClientCapabilities::Requests::range()
+std::optional<std::variant<bool, QJsonObject>> SemanticTokensClientCapabilities::Requests::range()
     const
 {
     using RetType = std::variant<bool, QJsonObject>;
@@ -34,7 +33,7 @@ Utils::optional<std::variant<bool, QJsonObject>> SemanticTokensClientCapabilitie
         return RetType(rangeOptions.toBool());
     if (rangeOptions.isObject())
         return RetType(rangeOptions.toObject());
-    return Utils::nullopt;
+    return std::nullopt;
 }
 
 void SemanticTokensClientCapabilities::Requests::setRange(
@@ -43,7 +42,7 @@ void SemanticTokensClientCapabilities::Requests::setRange(
     insertVariant<bool, QJsonObject>(rangeKey, range);
 }
 
-Utils::optional<std::variant<bool, FullSemanticTokenOptions>>
+std::optional<std::variant<bool, FullSemanticTokenOptions>>
 SemanticTokensClientCapabilities::Requests::full() const
 {
     using RetType = std::variant<bool, FullSemanticTokenOptions>;
@@ -52,7 +51,7 @@ SemanticTokensClientCapabilities::Requests::full() const
         return RetType(fullOptions.toBool());
     if (fullOptions.isObject())
         return RetType(FullSemanticTokenOptions(fullOptions.toObject()));
-    return Utils::nullopt;
+    return std::nullopt;
 }
 
 void SemanticTokensClientCapabilities::Requests::setFull(
@@ -61,8 +60,7 @@ void SemanticTokensClientCapabilities::Requests::setFull(
     insertVariant<bool, FullSemanticTokenOptions>(fullKey, full);
 }
 
-Utils::optional<SemanticTokensClientCapabilities> TextDocumentClientCapabilities::semanticTokens()
-    const
+std::optional<SemanticTokensClientCapabilities> TextDocumentClientCapabilities::semanticTokens() const
 {
     return optionalValue<SemanticTokensClientCapabilities>(semanticTokensKey);
 }
diff --git a/src/libs/languageserverprotocol/clientcapabilities.h b/src/libs/languageserverprotocol/clientcapabilities.h
index 4bbfaf723d..409081a230 100644
--- a/src/libs/languageserverprotocol/clientcapabilities.h
+++ b/src/libs/languageserverprotocol/clientcapabilities.h
@@ -14,7 +14,10 @@ class LANGUAGESERVERPROTOCOL_EXPORT DynamicRegistrationCapabilities : public Jso
 public:
     using JsonObject::JsonObject;
 
-    Utils::optional<bool> dynamicRegistration() const { return optionalValue<bool>(dynamicRegistrationKey); }
+    std::optional<bool> dynamicRegistration() const
+    {
+        return optionalValue<bool>(dynamicRegistrationKey);
+    }
     void setDynamicRegistration(bool dynamicRegistration) { insert(dynamicRegistrationKey, dynamicRegistration); }
     void clearDynamicRegistration() { remove(dynamicRegistrationKey); }
 };
@@ -28,7 +31,7 @@ public:
       * The client will send the `textDocument/semanticTokens/full/delta`
       * request if the server provides a corresponding handler.
       */
-    Utils::optional<bool> delta() const { return optionalValue<bool>(deltaKey); }
+    std::optional<bool> delta() const { return optionalValue<bool>(deltaKey); }
     void setDelta(bool delta) { insert(deltaKey, delta); }
     void clearDelta() { remove(deltaKey); }
 };
@@ -56,7 +59,7 @@ public:
          * The client will send the `textDocument/semanticTokens/range` request
          * if the server provides a corresponding handler.
          */
-        Utils::optional<std::variant<bool, QJsonObject>> range() const;
+        std::optional<std::variant<bool, QJsonObject>> range() const;
         void setRange(const std::variant<bool, QJsonObject> &range);
         void clearRange() { remove(rangeKey); }
 
@@ -64,7 +67,7 @@ public:
          * The client will send the `textDocument/semanticTokens/full` request
          * if the server provides a corresponding handler.
          */
-        Utils::optional<std::variant<bool, FullSemanticTokenOptions>> full() const;
+        std::optional<std::variant<bool, FullSemanticTokenOptions>> full() const;
         void setFull(const std::variant<bool, FullSemanticTokenOptions> &full);
         void clearFull() { remove(fullKey); }
     };
@@ -85,12 +88,18 @@ public:
     void setFormats(const QList<QString> &value) { insertArray(formatsKey, value); }
 
     /// Whether the client supports tokens that can overlap each other.
-    Utils::optional<bool> overlappingTokenSupport() const { return optionalValue<bool>(overlappingTokenSupportKey); }
+    std::optional<bool> overlappingTokenSupport() const
+    {
+        return optionalValue<bool>(overlappingTokenSupportKey);
+    }
     void setOverlappingTokenSupport(bool overlappingTokenSupport) { insert(overlappingTokenSupportKey, overlappingTokenSupport); }
     void clearOverlappingTokenSupport() { remove(overlappingTokenSupportKey); }
 
     /// Whether the client supports tokens that can span multiple lines.
-    Utils::optional<bool> multiLineTokenSupport() const { return optionalValue<bool>(multiLineTokenSupportKey); }
+    std::optional<bool> multiLineTokenSupport() const
+    {
+        return optionalValue<bool>(multiLineTokenSupportKey);
+    }
     void setMultiLineTokenSupport(bool multiLineTokenSupport) { insert(multiLineTokenSupportKey, multiLineTokenSupport); }
     void clearMultiLineTokenSupport() { remove(multiLineTokenSupportKey); }
 
@@ -117,18 +126,18 @@ public:
          * the symbol kinds from `File` to `Array` as defined in
          * the initial version of the protocol.
          */
-        Utils::optional<QList<SymbolKind>> valueSet() const;
+        std::optional<QList<SymbolKind>> valueSet() const;
         void setValueSet(const QList<SymbolKind> &valueSet);
         void clearValueSet() { remove(valueSetKey); }
     };
 
     // Specific capabilities for the `SymbolKind` in the `workspace/symbol` request.
-    Utils::optional<SymbolKindCapabilities> symbolKind() const
+    std::optional<SymbolKindCapabilities> symbolKind() const
     { return optionalValue<SymbolKindCapabilities>(symbolKindKey); }
     void setSymbolKind(const SymbolKindCapabilities &symbolKind) { insert(symbolKindKey, symbolKind); }
     void clearSymbolKind() { remove(symbolKindKey); }
 
-    Utils::optional<bool> hierarchicalDocumentSymbolSupport() const
+    std::optional<bool> hierarchicalDocumentSymbolSupport() const
     { return optionalValue<bool>(hierarchicalDocumentSymbolSupportKey); }
     void setHierarchicalDocumentSymbolSupport(bool hierarchicalDocumentSymbolSupport)
     { insert(hierarchicalDocumentSymbolSupportKey, hierarchicalDocumentSymbolSupport); }
@@ -146,7 +155,7 @@ public:
         using DynamicRegistrationCapabilities::DynamicRegistrationCapabilities;
 
         // The client supports sending will save notifications.
-        Utils::optional<bool> willSave() const { return optionalValue<bool>(willSaveKey); }
+        std::optional<bool> willSave() const { return optionalValue<bool>(willSaveKey); }
         void setWillSave(bool willSave) { insert(willSaveKey, willSave); }
         void clearWillSave() { remove(willSaveKey); }
 
@@ -155,19 +164,19 @@ public:
          * waits for a response providing text edits which will
          * be applied to the document before it is saved.
          */
-        Utils::optional<bool> willSaveWaitUntil() const
+        std::optional<bool> willSaveWaitUntil() const
         { return optionalValue<bool>(willSaveWaitUntilKey); }
         void setWillSaveWaitUntil(bool willSaveWaitUntil)
         { insert(willSaveWaitUntilKey, willSaveWaitUntil); }
         void clearWillSaveWaitUntil() { remove(willSaveWaitUntilKey); }
 
         // The client supports did save notifications.
-        Utils::optional<bool> didSave() const { return optionalValue<bool>(didSaveKey); }
+        std::optional<bool> didSave() const { return optionalValue<bool>(didSaveKey); }
         void setDidSave(bool didSave) { insert(didSaveKey, didSave); }
         void clearDidSave() { remove(didSaveKey); }
     };
 
-    Utils::optional<SynchronizationCapabilities> synchronization() const
+    std::optional<SynchronizationCapabilities> synchronization() const
     { return optionalValue<SynchronizationCapabilities>(synchronizationKey); }
     void setSynchronization(const SynchronizationCapabilities &synchronization)
     { insert(synchronizationKey, synchronization); }
@@ -191,14 +200,14 @@ public:
              * the end of the snippet. Placeholders with equal identifiers are linked,
              * that is typing in one will update others too.
              */
-            Utils::optional<bool> snippetSupport() const
+            std::optional<bool> snippetSupport() const
             { return optionalValue<bool>(snippetSupportKey); }
             void setSnippetSupport(bool snippetSupport)
             { insert(snippetSupportKey, snippetSupport); }
             void clearSnippetSupport() { remove(snippetSupportKey); }
 
             // Client supports commit characters on a completion item.
-            Utils::optional<bool> commitCharacterSupport() const
+            std::optional<bool> commitCharacterSupport() const
             { return optionalValue<bool>(commitCharacterSupportKey); }
             void setCommitCharacterSupport(bool commitCharacterSupport)
             { insert(commitCharacterSupportKey, commitCharacterSupport); }
@@ -208,13 +217,13 @@ public:
              * Client supports the follow content formats for the documentation
              * property. The order describes the preferred format of the client.
              */
-            Utils::optional<QList<MarkupKind>> documentationFormat() const;
+            std::optional<QList<MarkupKind>> documentationFormat() const;
             void setDocumentationFormat(const QList<MarkupKind> &documentationFormat);
             void clearDocumentationFormat() { remove(documentationFormatKey); }
         };
 
         // The client supports the following `CompletionItem` specific capabilities.
-        Utils::optional<CompletionItemCapbilities> completionItem() const
+        std::optional<CompletionItemCapbilities> completionItem() const
         { return optionalValue<CompletionItemCapbilities>(completionItemKey); }
         void setCompletionItem(const CompletionItemCapbilities &completionItem)
         { insert(completionItemKey, completionItem); }
@@ -235,12 +244,12 @@ public:
              * the completion items kinds from `Text` to `Reference` as defined in
              * the initial version of the protocol.
              */
-            Utils::optional<QList<CompletionItemKind::Kind>> valueSet() const;
+            std::optional<QList<CompletionItemKind::Kind>> valueSet() const;
             void setValueSet(const QList<CompletionItemKind::Kind> &valueSet);
             void clearValueSet() { remove(valueSetKey); }
         };
 
-        Utils::optional<CompletionItemKindCapabilities> completionItemKind() const
+        std::optional<CompletionItemKindCapabilities> completionItemKind() const
         { return optionalValue<CompletionItemKindCapabilities>(completionItemKindKey); }
         void setCompletionItemKind(const CompletionItemKindCapabilities &completionItemKind)
         { insert(completionItemKindKey, completionItemKind); }
@@ -250,13 +259,16 @@ public:
          * The client supports to send additional context information for a
          * `textDocument/completion` request.
          */
-        Utils::optional<bool> contextSupport() const { return optionalValue<bool>(contextSupportKey); }
+        std::optional<bool> contextSupport() const
+        {
+            return optionalValue<bool>(contextSupportKey);
+        }
         void setContextSupport(bool contextSupport) { insert(contextSupportKey, contextSupport); }
         void clearContextSupport() { remove(contextSupportKey); }
     };
 
     // Capabilities specific to the `textDocument/completion`
-    Utils::optional<CompletionCapabilities> completion() const
+    std::optional<CompletionCapabilities> completion() const
     { return optionalValue<CompletionCapabilities>(completionKey); }
     void setCompletion(const CompletionCapabilities &completion)
     { insert(completionKey, completion); }
@@ -270,12 +282,15 @@ public:
          * Client supports the follow content formats for the content
          * property. The order describes the preferred format of the client.
          */
-        Utils::optional<QList<MarkupKind>> contentFormat() const;
+        std::optional<QList<MarkupKind>> contentFormat() const;
         void setContentFormat(const QList<MarkupKind> &contentFormat);
         void clearContentFormat() { remove(contentFormatKey); }
     };
 
-    Utils::optional<HoverCapabilities> hover() const { return optionalValue<HoverCapabilities>(hoverKey); }
+    std::optional<HoverCapabilities> hover() const
+    {
+        return optionalValue<HoverCapabilities>(hoverKey);
+    }
     void setHover(const HoverCapabilities &hover) { insert(hoverKey, hover); }
     void clearHover() { remove(hoverKey); }
 
@@ -292,11 +307,11 @@ public:
              * Client supports the follow content formats for the documentation
              * property. The order describes the preferred format of the client.
              */
-            Utils::optional<QList<MarkupKind>> documentationFormat() const;
+            std::optional<QList<MarkupKind>> documentationFormat() const;
             void setDocumentationFormat(const QList<MarkupKind> &documentationFormat);
             void clearDocumentationFormat() { remove(documentationFormatKey); }
 
-            Utils::optional<bool> activeParameterSupport() const
+            std::optional<bool> activeParameterSupport() const
             { return optionalValue<bool>(activeParameterSupportKey); }
             void setActiveParameterSupport(bool activeParameterSupport)
             { insert(activeParameterSupportKey, activeParameterSupport); }
@@ -304,7 +319,7 @@ public:
         };
 
         // The client supports the following `SignatureInformation` specific properties.
-        Utils::optional<SignatureInformationCapabilities> signatureInformation() const
+        std::optional<SignatureInformationCapabilities> signatureInformation() const
         { return optionalValue<SignatureInformationCapabilities>(signatureInformationKey); }
         void setSignatureInformation(const SignatureInformationCapabilities &signatureInformation)
         { insert(signatureInformationKey, signatureInformation); }
@@ -312,56 +327,56 @@ public:
     };
 
     // Capabilities specific to the `textDocument/signatureHelp`
-    Utils::optional<SignatureHelpCapabilities> signatureHelp() const
+    std::optional<SignatureHelpCapabilities> signatureHelp() const
     { return optionalValue<SignatureHelpCapabilities>(signatureHelpKey); }
     void setSignatureHelp(const SignatureHelpCapabilities &signatureHelp)
     { insert(signatureHelpKey, signatureHelp); }
     void clearSignatureHelp() { remove(signatureHelpKey); }
 
     // Whether references supports dynamic registration.
-    Utils::optional<DynamicRegistrationCapabilities> references() const
+    std::optional<DynamicRegistrationCapabilities> references() const
     { return optionalValue<DynamicRegistrationCapabilities>(referencesKey); }
     void setReferences(const DynamicRegistrationCapabilities &references)
     { insert(referencesKey, references); }
     void clearReferences() { remove(referencesKey); }
 
     // Whether document highlight supports dynamic registration.
-    Utils::optional<DynamicRegistrationCapabilities> documentHighlight() const
+    std::optional<DynamicRegistrationCapabilities> documentHighlight() const
     { return optionalValue<DynamicRegistrationCapabilities>(documentHighlightKey); }
     void setDocumentHighlight(const DynamicRegistrationCapabilities &documentHighlight)
     { insert(documentHighlightKey, documentHighlight); }
     void clearDocumentHighlight() { remove(documentHighlightKey); }
 
     // Capabilities specific to the `textDocument/documentSymbol`
-    Utils::optional<SymbolCapabilities> documentSymbol() const
+    std::optional<SymbolCapabilities> documentSymbol() const
     { return optionalValue<SymbolCapabilities>(documentSymbolKey); }
     void setDocumentSymbol(const SymbolCapabilities &documentSymbol)
     { insert(documentSymbolKey, documentSymbol); }
     void clearDocumentSymbol() { remove(documentSymbolKey); }
 
     // Whether formatting supports dynamic registration.
-    Utils::optional<DynamicRegistrationCapabilities> formatting() const
+    std::optional<DynamicRegistrationCapabilities> formatting() const
     { return optionalValue<DynamicRegistrationCapabilities>(formattingKey); }
     void setFormatting(const DynamicRegistrationCapabilities &formatting)
     { insert(formattingKey, formatting); }
     void clearFormatting() { remove(formattingKey); }
 
     // Whether range formatting supports dynamic registration.
-    Utils::optional<DynamicRegistrationCapabilities> rangeFormatting() const
+    std::optional<DynamicRegistrationCapabilities> rangeFormatting() const
     { return optionalValue<DynamicRegistrationCapabilities>(rangeFormattingKey); }
     void setRangeFormatting(const DynamicRegistrationCapabilities &rangeFormatting)
     { insert(rangeFormattingKey, rangeFormatting); }
     void clearRangeFormatting() { remove(rangeFormattingKey); }
 
     // Whether on type formatting supports dynamic registration.
-    Utils::optional<DynamicRegistrationCapabilities> onTypeFormatting() const
+    std::optional<DynamicRegistrationCapabilities> onTypeFormatting() const
     { return optionalValue<DynamicRegistrationCapabilities>(onTypeFormattingKey); }
     void setOnTypeFormatting(const DynamicRegistrationCapabilities &onTypeFormatting)
     { insert(onTypeFormattingKey, onTypeFormatting); }
     void clearOnTypeFormatting() { remove(onTypeFormattingKey); }
 
     // Whether definition supports dynamic registration.
-    Utils::optional<DynamicRegistrationCapabilities> definition() const
+    std::optional<DynamicRegistrationCapabilities> definition() const
     { return optionalValue<DynamicRegistrationCapabilities>(definitionKey); }
     void setDefinition(const DynamicRegistrationCapabilities &definition)
     { insert(definitionKey, definition); }
@@ -372,7 +387,7 @@ public:
      * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
      * return value for the corresponding server capability as well.
      */
-    Utils::optional<DynamicRegistrationCapabilities> typeDefinition() const
+    std::optional<DynamicRegistrationCapabilities> typeDefinition() const
     { return optionalValue<DynamicRegistrationCapabilities>(typeDefinitionKey); }
     void setTypeDefinition(const DynamicRegistrationCapabilities &typeDefinition)
     { insert(typeDefinitionKey, typeDefinition); }
@@ -383,7 +398,7 @@ public:
      * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
      * return value for the corresponding server capability as well.
      */
-    Utils::optional<DynamicRegistrationCapabilities> implementation() const
+    std::optional<DynamicRegistrationCapabilities> implementation() const
     { return optionalValue<DynamicRegistrationCapabilities>(implementationKey); }
     void setImplementation(const DynamicRegistrationCapabilities &implementation)
     { insert(implementationKey, implementation); }
@@ -421,7 +436,7 @@ public:
             bool isValid() const override { return contains(codeActionKindKey); }
         };
 
-        Utils::optional<CodeActionLiteralSupport> codeActionLiteralSupport() const
+        std::optional<CodeActionLiteralSupport> codeActionLiteralSupport() const
         { return optionalValue<CodeActionLiteralSupport>(codeActionLiteralSupportKey); }
         void setCodeActionLiteralSupport(const CodeActionLiteralSupport &codeActionLiteralSupport)
         { insert(codeActionLiteralSupportKey, codeActionLiteralSupport); }
@@ -429,21 +444,21 @@ public:
     };
 
     // Whether code action supports dynamic registration.
-    Utils::optional<CodeActionCapabilities> codeAction() const
+    std::optional<CodeActionCapabilities> codeAction() const
     { return optionalValue<CodeActionCapabilities>(codeActionKey); }
     void setCodeAction(const CodeActionCapabilities &codeAction)
     { insert(codeActionKey, codeAction); }
     void clearCodeAction() { remove(codeActionKey); }
 
     // Whether code lens supports dynamic registration.
-    Utils::optional<DynamicRegistrationCapabilities> codeLens() const
+    std::optional<DynamicRegistrationCapabilities> codeLens() const
     { return optionalValue<DynamicRegistrationCapabilities>(codeLensKey); }
     void setCodeLens(const DynamicRegistrationCapabilities &codeLens)
     { insert(codeLensKey, codeLens); }
     void clearCodeLens() { remove(codeLensKey); }
 
     // Whether document link supports dynamic registration.
-    Utils::optional<DynamicRegistrationCapabilities> documentLink() const
+    std::optional<DynamicRegistrationCapabilities> documentLink() const
     { return optionalValue<DynamicRegistrationCapabilities>(documentLinkKey); }
     void setDocumentLink(const DynamicRegistrationCapabilities &documentLink)
     { insert(documentLinkKey, documentLink); }
@@ -454,7 +469,7 @@ public:
      * the client supports the new `(ColorProviderOptions & TextDocumentRegistrationOptions & StaticRegistrationOptions)`
      * return value for the corresponding server capability as well.
      */
-    Utils::optional<DynamicRegistrationCapabilities> colorProvider() const
+    std::optional<DynamicRegistrationCapabilities> colorProvider() const
     { return optionalValue<DynamicRegistrationCapabilities>(colorProviderKey); }
     void setColorProvider(const DynamicRegistrationCapabilities &colorProvider)
     { insert(colorProviderKey, colorProvider); }
@@ -471,19 +486,22 @@ public:
          * @since version 3.12.0
          */
 
-        Utils::optional<bool> prepareSupport() const { return optionalValue<bool>(prepareSupportKey); }
+        std::optional<bool> prepareSupport() const
+        {
+            return optionalValue<bool>(prepareSupportKey);
+        }
         void setPrepareSupport(bool prepareSupport) { insert(prepareSupportKey, prepareSupport); }
         void clearPrepareSupport() { remove(prepareSupportKey); }
     };
 
     // Whether rename supports dynamic registration.
-    Utils::optional<RenameClientCapabilities> rename() const
+    std::optional<RenameClientCapabilities> rename() const
     { return optionalValue<RenameClientCapabilities>(renameKey); }
     void setRename(const RenameClientCapabilities &rename)
     { insert(renameKey, rename); }
     void clearRename() { remove(renameKey); }
 
-    Utils::optional<SemanticTokensClientCapabilities> semanticTokens() const;
+    std::optional<SemanticTokensClientCapabilities> semanticTokens() const;
     void setSemanticTokens(const SemanticTokensClientCapabilities &semanticTokens);
     void clearSemanticTokens() { remove(semanticTokensKey); }
 };
@@ -501,7 +519,7 @@ public:
      * and is useful for situation where a server for example detect a project
      * wide change that requires such a calculation.
      */
-    Utils::optional<bool> refreshSupport() const { return optionalValue<bool>(refreshSupportKey); }
+    std::optional<bool> refreshSupport() const { return optionalValue<bool>(refreshSupportKey); }
     void setRefreshSupport(bool refreshSupport) { insert(refreshSupportKey, refreshSupport); }
     void clearRefreshSupport() { remove(refreshSupportKey); }
 };
@@ -516,7 +534,7 @@ public:
      * The client supports applying batch edits to the workspace by supporting the request
      * 'workspace/applyEdit'
      */
-    Utils::optional<bool> applyEdit() const { return optionalValue<bool>(applyEditKey); }
+    std::optional<bool> applyEdit() const { return optionalValue<bool>(applyEditKey); }
     void setApplyEdit(bool applyEdit) { insert(applyEditKey, applyEdit); }
     void clearApplyEdit() { remove(applyEditKey); }
 
@@ -526,7 +544,7 @@ public:
         using JsonObject::JsonObject;
 
         // The client supports versioned document changes in `WorkspaceEdit`s
-        Utils::optional<bool> documentChanges() const
+        std::optional<bool> documentChanges() const
         { return optionalValue<bool>(documentChangesKey); }
         void setDocumentChanges(bool documentChanges)
         { insert(documentChangesKey, documentChanges); }
@@ -534,52 +552,52 @@ public:
     };
 
     // Capabilities specific to `WorkspaceEdit`s
-    Utils::optional<WorkspaceEditCapabilities> workspaceEdit() const
+    std::optional<WorkspaceEditCapabilities> workspaceEdit() const
     { return optionalValue<WorkspaceEditCapabilities>(workspaceEditKey); }
     void setWorkspaceEdit(const WorkspaceEditCapabilities &workspaceEdit)
     { insert(workspaceEditKey, workspaceEdit); }
     void clearWorkspaceEdit() { remove(workspaceEditKey); }
 
     // Capabilities specific to the `workspace/didChangeConfiguration` notification.
-    Utils::optional<DynamicRegistrationCapabilities> didChangeConfiguration() const
+    std::optional<DynamicRegistrationCapabilities> didChangeConfiguration() const
     { return optionalValue<DynamicRegistrationCapabilities>(didChangeConfigurationKey); }
     void setDidChangeConfiguration(const DynamicRegistrationCapabilities &didChangeConfiguration)
     { insert(didChangeConfigurationKey, didChangeConfiguration); }
     void clearDidChangeConfiguration() { remove(didChangeConfigurationKey); }
 
     // Capabilities specific to the `workspace/didChangeWatchedFiles` notification.
-    Utils::optional<DynamicRegistrationCapabilities> didChangeWatchedFiles() const
+    std::optional<DynamicRegistrationCapabilities> didChangeWatchedFiles() const
     { return optionalValue<DynamicRegistrationCapabilities>(didChangeWatchedFilesKey); }
     void setDidChangeWatchedFiles(const DynamicRegistrationCapabilities &didChangeWatchedFiles)
     { insert(didChangeWatchedFilesKey, didChangeWatchedFiles); }
     void clearDidChangeWatchedFiles() { remove(didChangeWatchedFilesKey); }
 
     // Specific capabilities for the `SymbolKind` in the `workspace/symbol` request.
-    Utils::optional<SymbolCapabilities> symbol() const
+    std::optional<SymbolCapabilities> symbol() const
     { return optionalValue<SymbolCapabilities>(symbolKey); }
     void setSymbol(const SymbolCapabilities &symbol) { insert(symbolKey, symbol); }
     void clearSymbol() { remove(symbolKey); }
 
     // Capabilities specific to the `workspace/executeCommand` request.
-    Utils::optional<DynamicRegistrationCapabilities> executeCommand() const
+    std::optional<DynamicRegistrationCapabilities> executeCommand() const
     { return optionalValue<DynamicRegistrationCapabilities>(executeCommandKey); }
     void setExecuteCommand(const DynamicRegistrationCapabilities &executeCommand)
     { insert(executeCommandKey, executeCommand); }
     void clearExecuteCommand() { remove(executeCommandKey); }
 
     // The client has support for workspace folders. Since 3.6.0
-    Utils::optional<bool> workspaceFolders() const
+    std::optional<bool> workspaceFolders() const
     { return optionalValue<bool>(workspaceFoldersKey); }
     void setWorkspaceFolders(bool workspaceFolders)
     { insert(workspaceFoldersKey, workspaceFolders); }
     void clearWorkspaceFolders() { remove(workspaceFoldersKey); }
 
     // The client supports `workspace/configuration` requests. Since 3.6.0
-    Utils::optional<bool> configuration() const { return optionalValue<bool>(configurationKey); }
+    std::optional<bool> configuration() const { return optionalValue<bool>(configurationKey); }
     void setConfiguration(bool configuration) { insert(configurationKey, configuration); }
     void clearConfiguration() { remove(configurationKey); }
 
-    Utils::optional<SemanticTokensWorkspaceClientCapabilities> semanticTokens() const
+    std::optional<SemanticTokensWorkspaceClientCapabilities> semanticTokens() const
     { return optionalValue<SemanticTokensWorkspaceClientCapabilities>(semanticTokensKey); }
     void setSemanticTokens(const SemanticTokensWorkspaceClientCapabilities &semanticTokens)
     { insert(semanticTokensKey, semanticTokens); }
@@ -597,7 +615,7 @@ public:
       * in the request specific server capabilities.
       *
       */
-    Utils::optional<bool> workDoneProgress() const
+    std::optional<bool> workDoneProgress() const
     { return optionalValue<bool>(workDoneProgressKey); }
     void setWorkDoneProgress(bool workDoneProgress)
     { insert(workDoneProgressKey, workDoneProgress); }
@@ -613,21 +631,21 @@ public:
     using JsonObject::JsonObject;
 
     // Workspace specific client capabilities.
-    Utils::optional<WorkspaceClientCapabilities> workspace() const
+    std::optional<WorkspaceClientCapabilities> workspace() const
     { return optionalValue<WorkspaceClientCapabilities>(workspaceKey); }
     void setWorkspace(const WorkspaceClientCapabilities &workspace)
     { insert(workspaceKey, workspace); }
     void clearWorkspace() { remove(workspaceKey); }
 
     // Text document specific client capabilities.
-    Utils::optional<TextDocumentClientCapabilities> textDocument() const
+    std::optional<TextDocumentClientCapabilities> textDocument() const
     { return optionalValue<TextDocumentClientCapabilities>(textDocumentKey); }
     void setTextDocument(const TextDocumentClientCapabilities &textDocument)
     { insert(textDocumentKey, textDocument); }
     void clearTextDocument() { remove(textDocumentKey); }
 
     // Window specific client capabilities.
-    Utils::optional<WindowClientClientCapabilities> window() const
+    std::optional<WindowClientClientCapabilities> window() const
     { return optionalValue<WindowClientClientCapabilities>(windowKey); }
     void setWindow(const WindowClientClientCapabilities &window)
     { insert(windowKey, window); }
diff --git a/src/libs/languageserverprotocol/completion.cpp b/src/libs/languageserverprotocol/completion.cpp
index 99e204ccd7..543abb9cfc 100644
--- a/src/libs/languageserverprotocol/completion.cpp
+++ b/src/libs/languageserverprotocol/completion.cpp
@@ -12,22 +12,22 @@ CompletionRequest::CompletionRequest(const CompletionParams &params)
     : Request(methodName, params)
 { }
 
-Utils::optional<MarkupOrString> CompletionItem::documentation() const
+std::optional<MarkupOrString> CompletionItem::documentation() const
 {
     QJsonValue documentation = value(documentationKey);
     if (documentation.isUndefined())
-        return Utils::nullopt;
+        return std::nullopt;
     return MarkupOrString(documentation);
 }
 
-Utils::optional<CompletionItem::InsertTextFormat> CompletionItem::insertTextFormat() const
+std::optional<CompletionItem::InsertTextFormat> CompletionItem::insertTextFormat() const
 {
-    if (Utils::optional<int> value = optionalValue<int>(insertTextFormatKey))
-        return Utils::make_optional(CompletionItem::InsertTextFormat(*value));
-    return Utils::nullopt;
+    if (std::optional<int> value = optionalValue<int>(insertTextFormatKey))
+        return std::make_optional(CompletionItem::InsertTextFormat(*value));
+    return std::nullopt;
 }
 
-Utils::optional<QList<CompletionItem::CompletionItemTag>> CompletionItem::tags() const
+std::optional<QList<CompletionItem::CompletionItemTag>> CompletionItem::tags() const
 {
     if (const auto value = optionalValue<QJsonArray>(tagsKey)) {
         QList<CompletionItemTag> tags;
diff --git a/src/libs/languageserverprotocol/completion.h b/src/libs/languageserverprotocol/completion.h
index 6e623acaca..9537df5538 100644
--- a/src/libs/languageserverprotocol/completion.h
+++ b/src/libs/languageserverprotocol/completion.h
@@ -43,7 +43,7 @@ public:
          * The trigger character (a single character) that has trigger code complete.
          * Is undefined if `triggerKind !== CompletionTriggerKind.TriggerCharacter`
          */
-        Utils::optional<QString> triggerCharacter() const
+        std::optional<QString> triggerCharacter() const
         { return optionalValue<QString>(triggerCharacterKey); }
         void setTriggerCharacter(const QString &triggerCharacter)
         { insert(triggerCharacterKey, triggerCharacter); }
@@ -56,7 +56,7 @@ public:
      * The completion context. This is only available it the client specifies
      * to send this using `ClientCapabilities.textDocument.completion.contextSupport === true`
      */
-    Utils::optional<CompletionContext> context() const
+    std::optional<CompletionContext> context() const
     { return optionalValue<CompletionContext>(contextKey); }
     void setContext(const CompletionContext &context)
     { insert(contextKey, context); }
@@ -79,30 +79,30 @@ public:
     void setLabel(const QString &label) { insert(labelKey, label); }
 
     /// The kind of this completion item. Based of the kind an icon is chosen by the editor.
-    Utils::optional<int> kind() const { return optionalValue<int>(kindKey); }
+    std::optional<int> kind() const { return optionalValue<int>(kindKey); }
     void setKind(int kind) { insert(kindKey, kind); }
     void clearKind() { remove(kindKey); }
 
     /// A human-readable string with additional information about this item, like type information.
-    Utils::optional<QString> detail() const { return optionalValue<QString>(detailKey); }
+    std::optional<QString> detail() const { return optionalValue<QString>(detailKey); }
     void setDetail(const QString &detail) { insert(detailKey, detail); }
     void clearDetail() { remove(detailKey); }
 
     /// A human-readable string that represents a doc-comment.
-    Utils::optional<MarkupOrString> documentation() const;
+    std::optional<MarkupOrString> documentation() const;
     void setDocumentation(const MarkupOrString &documentation)
     { insert(documentationKey, documentation.toJson()); }
     void cleatDocumentation() { remove(documentationKey); }
 
     /// A string that should be used when comparing this item
     /// with other items. When `falsy` the label is used.
-    Utils::optional<QString> sortText() const { return optionalValue<QString>(sortTextKey); }
+    std::optional<QString> sortText() const { return optionalValue<QString>(sortTextKey); }
     void setSortText(const QString &sortText) { insert(sortTextKey, sortText); }
     void clearSortText() { remove(sortTextKey); }
 
     /// A string that should be used when filtering a set of
     /// completion items. When `falsy` the label is used.
-    Utils::optional<QString> filterText() const { return optionalValue<QString>(filterTextKey); }
+    std::optional<QString> filterText() const { return optionalValue<QString>(filterTextKey); }
     void setFilterText(const QString &filterText) { insert(filterTextKey, filterText); }
     void clearFilterText() { remove(filterTextKey); }
 
@@ -119,7 +119,7 @@ public:
      *
      * @deprecated Use textEdit instead.
      */
-    Utils::optional<QString> insertText() const { return optionalValue<QString>(insertTextKey); }
+    std::optional<QString> insertText() const { return optionalValue<QString>(insertTextKey); }
     void setInsertText(const QString &insertText) { insert(insertTextKey, insertText); }
     void clearInsertText() { remove(insertTextKey); }
 
@@ -140,7 +140,7 @@ public:
 
     /// The format of the insert text. The format applies to both the `insertText` property
     /// and the `newText` property of a provided `textEdit`.
-    Utils::optional<InsertTextFormat> insertTextFormat() const;
+    std::optional<InsertTextFormat> insertTextFormat() const;
     void setInsertTextFormat(const InsertTextFormat &insertTextFormat)
     { insert(insertTextFormatKey, insertTextFormat); }
     void clearInsertTextFormat() { remove(insertTextFormatKey); }
@@ -152,7 +152,7 @@ public:
      * *Note:* The range of the edit must be a single line range and it must contain the position at which completion
      * has been requested.
      */
-    Utils::optional<TextEdit> textEdit() const { return optionalValue<TextEdit>(textEditKey); }
+    std::optional<TextEdit> textEdit() const { return optionalValue<TextEdit>(textEditKey); }
     void setTextEdit(const TextEdit &textEdit) { insert(textEditKey, textEdit); }
     void clearTextEdit() { remove(textEditKey); }
 
@@ -161,7 +161,7 @@ public:
      * selecting this completion. Edits must not overlap with the main edit
      * nor with themselves.
      */
-    Utils::optional<QList<TextEdit>> additionalTextEdits() const
+    std::optional<QList<TextEdit>> additionalTextEdits() const
     { return optionalArray<TextEdit>(additionalTextEditsKey); }
     void setAdditionalTextEdits(const QList<TextEdit> &additionalTextEdits)
     { insertArray(additionalTextEditsKey, additionalTextEdits); }
@@ -172,7 +172,7 @@ public:
      * then type that character. *Note* that all commit characters should have `length=1` and that superfluous
      * characters will be ignored.
      */
-    Utils::optional<QList<QString>> commitCharacters() const
+    std::optional<QList<QString>> commitCharacters() const
     { return optionalArray<QString>(commitCharactersKey); }
     void setCommitCharacters(const QList<QString> &commitCharacters)
     { insertArray(commitCharactersKey, commitCharacters); }
@@ -183,7 +183,7 @@ public:
      * additional modifications to the current document should be described with the
      * additionalTextEdits-property.
      */
-    Utils::optional<Command> command() const { return optionalValue<Command>(commandKey); }
+    std::optional<Command> command() const { return optionalValue<Command>(commandKey); }
     void setCommand(const Command &command) { insert(commandKey, command); }
     void clearCommand() { remove(commandKey); }
 
@@ -191,7 +191,7 @@ public:
      * An data entry field that is preserved on a completion item between
      * a completion and a completion resolve request.
      */
-    Utils::optional<QJsonValue> data() const { return optionalValue<QJsonValue>(dataKey); }
+    std::optional<QJsonValue> data() const { return optionalValue<QJsonValue>(dataKey); }
     void setData(const QJsonValue &data) { insert(dataKey, data); }
     void clearData() { remove(dataKey); }
 
@@ -208,13 +208,13 @@ public:
      * Tags for this completion item.
      * @since 3.15.0
      */
-    Utils::optional<QList<CompletionItemTag>> tags() const;
+    std::optional<QList<CompletionItemTag>> tags() const;
 
     /**
       * Indicates if this item is deprecated.
       * @deprecated Use `tags` instead if supported.
       */
-    Utils::optional<bool> deprecated() const { return optionalValue<bool>(deprecatedKey); }
+    std::optional<bool> deprecated() const { return optionalValue<bool>(deprecatedKey); }
 
     bool isValid() const override { return contains(labelKey); }
 };
@@ -232,7 +232,7 @@ public:
     void setIsIncomplete(bool isIncomplete) { insert(isIncompleteKey, isIncomplete); }
 
     /// The completion items.
-    Utils::optional<QList<CompletionItem>> items() const { return array<CompletionItem>(itemsKey); }
+    std::optional<QList<CompletionItem>> items() const { return array<CompletionItem>(itemsKey); }
     void setItems(const QList<CompletionItem> &items) { insertArray(itemsKey, items); }
     void clearItems() { remove(itemsKey); }
 
diff --git a/src/libs/languageserverprotocol/diagnostics.h b/src/libs/languageserverprotocol/diagnostics.h
index 181172e875..f13cdac786 100644
--- a/src/libs/languageserverprotocol/diagnostics.h
+++ b/src/libs/languageserverprotocol/diagnostics.h
@@ -20,7 +20,7 @@ public:
     void setDiagnostics(const QList<Diagnostic> &diagnostics)
     { insertArray(diagnosticsKey, diagnostics); }
 
-    Utils::optional<int> version() const { return optionalValue<int>(versionKey); }
+    std::optional<int> version() const { return optionalValue<int>(versionKey); }
     void setVersion(int version) { insert(versionKey, version); }
     void clearVersion() { remove(versionKey); }
 
diff --git a/src/libs/languageserverprotocol/initializemessages.cpp b/src/libs/languageserverprotocol/initializemessages.cpp
index 288d7efc5d..4b6df50cfd 100644
--- a/src/libs/languageserverprotocol/initializemessages.cpp
+++ b/src/libs/languageserverprotocol/initializemessages.cpp
@@ -32,7 +32,7 @@ QString Trace::toString() const
 }
 #undef RETURN_CASE
 
-Utils::optional<QList<MarkupKind>>
+std::optional<QList<MarkupKind>>
 TextDocumentClientCapabilities::CompletionCapabilities::CompletionItemCapbilities::
 documentationFormat() const
 {
@@ -59,16 +59,16 @@ TextDocumentClientCapabilities::CompletionCapabilities::CompletionItemKindCapabi
                  CompletionItemKind::TypeParameter});
 }
 
-Utils::optional<QList<CompletionItemKind::Kind>>
+std::optional<QList<CompletionItemKind::Kind>>
 TextDocumentClientCapabilities::CompletionCapabilities::CompletionItemKindCapabilities::
 valueSet() const
 {
-    if (Utils::optional<QList<int>> array = optionalArray<int>(valueSetKey)) {
-        return Utils::make_optional(Utils::transform(*array, [] (int value) {
+    if (std::optional<QList<int>> array = optionalArray<int>(valueSetKey)) {
+        return std::make_optional(Utils::transform(*array, [](int value) {
             return static_cast<CompletionItemKind::Kind>(value);
         }));
     }
-    return Utils::nullopt;
+    return std::nullopt;
 }
 
 void
@@ -78,7 +78,7 @@ setValueSet(const QList<CompletionItemKind::Kind> &valueSet)
     insert(valueSetKey, enumArrayToJsonArray<CompletionItemKind::Kind>(valueSet));
 }
 
-Utils::optional<QList<MarkupKind> > TextDocumentClientCapabilities::HoverCapabilities::contentFormat() const
+std::optional<QList<MarkupKind> > TextDocumentClientCapabilities::HoverCapabilities::contentFormat() const
 {
     return optionalArray<MarkupKind>(contentFormatKey);
 }
@@ -88,7 +88,7 @@ void TextDocumentClientCapabilities::HoverCapabilities::setContentFormat(const Q
     insertArray(contentFormatKey, contentFormat);
 }
 
-Utils::optional<QList<MarkupKind>>
+std::optional<QList<MarkupKind>>
 TextDocumentClientCapabilities::SignatureHelpCapabilities::SignatureInformationCapabilities::
 documentationFormat() const
 {
@@ -110,20 +110,20 @@ InitializeParams::InitializeParams()
     setTrace(s_trace);
 }
 
-Utils::optional<QJsonObject> InitializeParams::initializationOptions() const
+std::optional<QJsonObject> InitializeParams::initializationOptions() const
 {
     const QJsonValue &optionsValue = value(initializationOptionsKey);
     if (optionsValue.isObject())
         return optionsValue.toObject();
-    return Utils::nullopt;
+    return std::nullopt;
 }
 
-Utils::optional<Trace> InitializeParams::trace() const
+std::optional<Trace> InitializeParams::trace() const
 {
     const QJsonValue &traceValue = value(traceKey);
     if (traceValue.isUndefined())
-        return Utils::nullopt;
-    return Utils::make_optional(Trace(traceValue.toString()));
+        return std::nullopt;
+    return std::make_optional(Trace(traceValue.toString()));
 }
 
 InitializeRequest::InitializeRequest(const InitializeParams &params)
diff --git a/src/libs/languageserverprotocol/initializemessages.h b/src/libs/languageserverprotocol/initializemessages.h
index 29e924e6c9..3573cdd817 100644
--- a/src/libs/languageserverprotocol/initializemessages.h
+++ b/src/libs/languageserverprotocol/initializemessages.h
@@ -39,7 +39,7 @@ public:
     QString name() const { return typedValue<QString>(nameKey); }
     void setName(const QString &name) { insert(nameKey, name); }
 
-    Utils::optional<QString> version() const { return optionalValue<QString>(versionKey); }
+    std::optional<QString> version() const { return optionalValue<QString>(versionKey); }
     void setVersion(const QString &version) { insert(versionKey, version); }
     void clearVersion() { remove(versionKey); }
 };
@@ -65,7 +65,7 @@ public:
      *
      * @deprecated in favor of rootUri.
      */
-    Utils::optional<LanguageClientValue<QString>> rootPath() const
+    std::optional<LanguageClientValue<QString>> rootPath() const
     { return optionalClientValue<QString>(rootPathKey); }
     void setRootPath(const LanguageClientValue<QString> &path)
     { insert(rootPathKey, path); }
@@ -82,7 +82,7 @@ public:
     { insert(rootUriKey, uri); }
 
     // User provided initialization options.
-    Utils::optional<QJsonObject> initializationOptions() const;
+    std::optional<QJsonObject> initializationOptions() const;
     void setInitializationOptions(const QJsonObject &options)
     { insert(initializationOptionsKey, options); }
     void clearInitializationOptions() { remove(initializationOptionsKey); }
@@ -93,7 +93,7 @@ public:
     { insert(capabilitiesKey, capabilities); }
 
     // The initial trace setting. If omitted trace is disabled ('off').
-    Utils::optional<Trace> trace() const;
+    std::optional<Trace> trace() const;
     void setTrace(Trace trace) { insert(traceKey, trace.toString()); }
     void clearTrace() { remove(traceKey); }
 
@@ -105,13 +105,13 @@ public:
      *
      * Since 3.6.0
      */
-    Utils::optional<LanguageClientArray<WorkSpaceFolder>> workspaceFolders() const
+    std::optional<LanguageClientArray<WorkSpaceFolder>> workspaceFolders() const
     { return optionalClientArray<WorkSpaceFolder>(workspaceFoldersKey); }
     void setWorkSpaceFolders(const LanguageClientArray<WorkSpaceFolder> &folders)
     { insert(workspaceFoldersKey, folders.toJson()); }
     void clearWorkSpaceFolders() { remove(workspaceFoldersKey); }
 
-    Utils::optional<ClientInfo> clientInfo() const { return optionalValue<ClientInfo>(clientInfoKey); }
+    std::optional<ClientInfo> clientInfo() const { return optionalValue<ClientInfo>(clientInfoKey); }
     void setClientInfo(const ClientInfo &clientInfo) { insert(clientInfoKey, clientInfo); }
     void clearClientInfo() { remove(clientInfoKey); }
 
@@ -137,7 +137,7 @@ public:
     using JsonObject::JsonObject;
 
     QString name() const { return typedValue<QString>(nameKey); }
-    Utils::optional<QString> version() const { return optionalValue<QString>(versionKey); }
+    std::optional<QString> version() const { return optionalValue<QString>(versionKey); }
 
     bool isValid() const override { return contains(nameKey); }
 };
@@ -152,7 +152,7 @@ public:
     void setCapabilities(const ServerCapabilities &capabilities)
     { insert(capabilitiesKey, capabilities); }
 
-    Utils::optional<ServerInfo> serverInfo() const
+    std::optional<ServerInfo> serverInfo() const
     { return optionalValue<ServerInfo>(serverInfoKey); }
 
     bool isValid() const override { return contains(capabilitiesKey); }
diff --git a/src/libs/languageserverprotocol/jsonobject.h b/src/libs/languageserverprotocol/jsonobject.h
index cde35b1863..1d04634fea 100644
--- a/src/libs/languageserverprotocol/jsonobject.h
+++ b/src/libs/languageserverprotocol/jsonobject.h
@@ -65,19 +65,19 @@ protected:
     template<typename T>
     T typedValue(const QStringView key) const;
     template<typename T>
-    Utils::optional<T> optionalValue(const QStringView key) const;
+    std::optional<T> optionalValue(const QStringView key) const;
     template<typename T>
     LanguageClientValue<T> clientValue(const QStringView key) const;
     template<typename T>
-    Utils::optional<LanguageClientValue<T>> optionalClientValue(const QStringView key) const;
+    std::optional<LanguageClientValue<T>> optionalClientValue(const QStringView key) const;
     template<typename T>
     QList<T> array(const QStringView key) const;
     template<typename T>
-    Utils::optional<QList<T>> optionalArray(const QStringView key) const;
+    std::optional<QList<T>> optionalArray(const QStringView key) const;
     template<typename T>
     LanguageClientArray<T> clientArray(const QStringView key) const;
     template<typename T>
-    Utils::optional<LanguageClientArray<T>> optionalClientArray(const QStringView key) const;
+    std::optional<LanguageClientArray<T>> optionalClientArray(const QStringView key) const;
     template<typename T>
     void insertArray(const QStringView key, const QList<T> &array);
     template<typename>
@@ -107,10 +107,10 @@ T JsonObject::typedValue(const QStringView key) const
 }
 
 template<typename T>
-Utils::optional<T> JsonObject::optionalValue(const QStringView key) const
+std::optional<T> JsonObject::optionalValue(const QStringView key) const
 {
     const QJsonValue &val = value(key);
-    return val.isUndefined() ? Utils::nullopt : Utils::make_optional(fromJsonValue<T>(val));
+    return val.isUndefined() ? std::nullopt : std::make_optional(fromJsonValue<T>(val));
 }
 
 template<typename T>
@@ -120,26 +120,26 @@ LanguageClientValue<T> JsonObject::clientValue(const QStringView key) const
 }
 
 template<typename T>
-Utils::optional<LanguageClientValue<T>> JsonObject::optionalClientValue(const QStringView key) const
+std::optional<LanguageClientValue<T>> JsonObject::optionalClientValue(const QStringView key) const
 {
-    return contains(key) ? Utils::make_optional(clientValue<T>(key)) : Utils::nullopt;
+    return contains(key) ? std::make_optional(clientValue<T>(key)) : std::nullopt;
 }
 
 template<typename T>
 QList<T> JsonObject::array(const QStringView key) const
 {
-    if (const Utils::optional<QList<T>> &array = optionalArray<T>(key))
+    if (const std::optional<QList<T>> &array = optionalArray<T>(key))
         return *array;
     qCDebug(conversionLog) << QString("Expected array under %1 in:").arg(key) << *this;
     return {};
 }
 
 template<typename T>
-Utils::optional<QList<T>> JsonObject::optionalArray(const QStringView key) const
+std::optional<QList<T>> JsonObject::optionalArray(const QStringView key) const
 {
     const QJsonValue &jsonValue = value(key);
     if (jsonValue.isUndefined())
-        return Utils::nullopt;
+        return std::nullopt;
     return Utils::transform<QList<T>>(jsonValue.toArray(), &fromJsonValue<T>);
 }
 
@@ -150,11 +150,11 @@ LanguageClientArray<T> JsonObject::clientArray(const QStringView key) const
 }
 
 template<typename T>
-Utils::optional<LanguageClientArray<T>> JsonObject::optionalClientArray(const QStringView key) const
+std::optional<LanguageClientArray<T>> JsonObject::optionalClientArray(const QStringView key) const
 {
     const QJsonValue &val = value(key);
-    return !val.isUndefined() ? Utils::make_optional(LanguageClientArray<T>(value(key)))
-                              : Utils::nullopt;
+    return !val.isUndefined() ? std::make_optional(LanguageClientArray<T>(value(key)))
+                              : std::nullopt;
 }
 
 template<typename T>
diff --git a/src/libs/languageserverprotocol/jsonrpcmessages.h b/src/libs/languageserverprotocol/jsonrpcmessages.h
index 927647db60..3886dcbc9e 100644
--- a/src/libs/languageserverprotocol/jsonrpcmessages.h
+++ b/src/libs/languageserverprotocol/jsonrpcmessages.h
@@ -7,7 +7,6 @@
 #include "lsptypes.h"
 #include "jsonkeys.h"
 
-#include <utils/optional.h>
 #include <utils/qtcassert.h>
 
 #include <QDebug>
@@ -18,6 +17,7 @@
 #include <QCoreApplication>
 #include <QUuid>
 
+#include <optional>
 #include <variant>
 
 namespace LanguageServerProtocol {
@@ -112,8 +112,7 @@ public:
 
     const QString parseError() { return m_parseError; }
 
-    virtual Utils::optional<ResponseHandler> responseHandler() const
-    { return Utils::nullopt; }
+    virtual std::optional<ResponseHandler> responseHandler() const { return std::nullopt; }
 
     BaseMessage toBaseMessage() const
     { return BaseMessage(jsonRpcMimeType(), toRawData()); }
@@ -143,10 +142,10 @@ public:
     void setMethod(const QString &method)
     { m_jsonObject.insert(methodKey, method); }
 
-    Utils::optional<Params> params() const
+    std::optional<Params> params() const
     {
         const QJsonValue &params = m_jsonObject.value(paramsKey);
-        return params.isUndefined() ? Utils::nullopt : Utils::make_optional(Params(params));
+        return params.isUndefined() ? std::nullopt : std::make_optional(Params(params));
     }
     void setParams(const Params &params)
     { m_jsonObject.insert(paramsKey, QJsonValue(params)); }
@@ -187,7 +186,7 @@ public:
     void setMethod(const QString &method)
     { m_jsonObject.insert(methodKey, method); }
 
-    Utils::optional<std::nullptr_t> params() const
+    std::optional<std::nullptr_t> params() const
     { return nullptr; }
     void setParams(const std::nullptr_t &/*params*/)
     { m_jsonObject.insert(paramsKey, QJsonValue::Null); }
@@ -216,7 +215,7 @@ public:
     QString message() const { return typedValue<QString>(messageKey); }
     void setMessage(const QString &message) { insert(messageKey, message); }
 
-    Utils::optional<Error> data() const { return optionalValue<Error>(dataKey); }
+    std::optional<Error> data() const { return optionalValue<Error>(dataKey); }
     void setData(const Error &data) { insert(dataKey, data); }
     void clearData() { remove(dataKey); }
 
@@ -275,22 +274,21 @@ public:
     void setId(MessageId id)
     { this->m_jsonObject.insert(idKey, id); }
 
-    Utils::optional<Result> result() const
+    std::optional<Result> result() const
     {
         const QJsonValue &result = m_jsonObject.value(resultKey);
         if (result.isUndefined())
-            return Utils::nullopt;
-        return Utils::make_optional(Result(result));
+            return std::nullopt;
+        return std::make_optional(Result(result));
     }
     void setResult(const Result &result) { m_jsonObject.insert(resultKey, QJsonValue(result)); }
     void clearResult() { m_jsonObject.remove(resultKey); }
 
     using Error = ResponseError<ErrorDataType>;
-    Utils::optional<Error> error() const
+    std::optional<Error> error() const
     {
         const QJsonValue &val = m_jsonObject.value(errorKey);
-        return val.isUndefined() ? Utils::nullopt
-                                 : Utils::make_optional(fromJsonValue<Error>(val));
+        return val.isUndefined() ? std::nullopt : std::make_optional(fromJsonValue<Error>(val));
     }
     void setError(const Error &error)
     { m_jsonObject.insert(errorKey, QJsonValue(error)); }
@@ -312,20 +310,18 @@ public:
     void setId(MessageId id)
     { this->m_jsonObject.insert(idKey, id); }
 
-    Utils::optional<std::nullptr_t> result() const
+    std::optional<std::nullptr_t> result() const
     {
-        return m_jsonObject.value(resultKey).isNull() ? Utils::make_optional(nullptr)
-                                                      : Utils::nullopt;
+        return m_jsonObject.value(resultKey).isNull() ? std::make_optional(nullptr) : std::nullopt;
     }
     void setResult(const std::nullptr_t &) { m_jsonObject.insert(resultKey, QJsonValue::Null); }
     void clearResult() { m_jsonObject.remove(resultKey); }
 
     using Error = ResponseError<ErrorDataType>;
-    Utils::optional<Error> error() const
+    std::optional<Error> error() const
     {
         const QJsonValue &val = m_jsonObject.value(errorKey);
-        return val.isUndefined() ? Utils::nullopt
-                                 : Utils::make_optional(fromJsonValue<Error>(val));
+        return val.isUndefined() ? std::nullopt : std::make_optional(fromJsonValue<Error>(val));
     }
     void setError(const Error &error)
     { m_jsonObject.insert(errorKey, QJsonValue(error)); }
@@ -357,7 +353,7 @@ public:
     void setResponseCallback(const ResponseCallback &callback)
     { m_callBack = callback; }
 
-    Utils::optional<ResponseHandler> responseHandler() const final
+    std::optional<ResponseHandler> responseHandler() const final
     {
         QElapsedTimer timer;
         timer.start();
@@ -369,7 +365,7 @@ public:
 
             callback(Response(message.toJsonObject()));
         };
-        return Utils::make_optional(ResponseHandler{id(), callback});
+        return std::make_optional(ResponseHandler{id(), callback});
     }
 
     bool isValid(QString *errorMessage) const override
diff --git a/src/libs/languageserverprotocol/languagefeatures.cpp b/src/libs/languageserverprotocol/languagefeatures.cpp
index 6b2ce364a0..3d605158bd 100644
--- a/src/libs/languageserverprotocol/languagefeatures.cpp
+++ b/src/libs/languageserverprotocol/languagefeatures.cpp
@@ -49,11 +49,11 @@ HoverRequest::HoverRequest(const TextDocumentPositionParams &params)
     : Request(methodName, params)
 { }
 
-Utils::optional<MarkupOrString> ParameterInformation::documentation() const
+std::optional<MarkupOrString> ParameterInformation::documentation() const
 {
     QJsonValue documentation = value(documentationKey);
     if (documentation.isUndefined())
-        return Utils::nullopt;
+        return std::nullopt;
     return MarkupOrString(documentation);
 }
 
@@ -81,7 +81,7 @@ DocumentSymbolsRequest::DocumentSymbolsRequest(const DocumentSymbolParams &param
     : Request(methodName, params)
 { }
 
-Utils::optional<QList<CodeActionKind> > CodeActionParams::CodeActionContext::only() const
+std::optional<QList<CodeActionKind> > CodeActionParams::CodeActionContext::only() const
 {
     return optionalArray<CodeActionKind>(onlyKey);
 }
@@ -180,16 +180,16 @@ RenameRequest::RenameRequest(const RenameParams &params)
     : Request(methodName, params)
 { }
 
-Utils::optional<DocumentUri> DocumentLink::target() const
+std::optional<DocumentUri> DocumentLink::target() const
 {
-    if (Utils::optional<QString> optionalTarget = optionalValue<QString>(targetKey))
-        return Utils::make_optional(DocumentUri::fromProtocol(*optionalTarget));
-    return Utils::nullopt;
+    if (std::optional<QString> optionalTarget = optionalValue<QString>(targetKey))
+        return std::make_optional(DocumentUri::fromProtocol(*optionalTarget));
+    return std::nullopt;
 }
 
-Utils::optional<QJsonValue> DocumentLink::data() const
+std::optional<QJsonValue> DocumentLink::data() const
 {
-    return contains(dataKey) ? Utils::make_optional(value(dataKey)) : Utils::nullopt;
+    return contains(dataKey) ? std::make_optional(value(dataKey)) : std::nullopt;
 }
 
 TextDocumentParams::TextDocumentParams()
@@ -376,9 +376,9 @@ PrepareRenameResult::PrepareRenameResult(const QJsonValue &val)
     }
 }
 
-Utils::optional<QJsonValue> CodeLens::data() const
+std::optional<QJsonValue> CodeLens::data() const
 {
-    return contains(dataKey) ? Utils::make_optional(value(dataKey)) : Utils::nullopt;
+    return contains(dataKey) ? std::make_optional(value(dataKey)) : std::nullopt;
 }
 
 HoverResult::HoverResult(const QJsonValue &value)
diff --git a/src/libs/languageserverprotocol/languagefeatures.h b/src/libs/languageserverprotocol/languagefeatures.h
index fac9bcf410..753aad67f3 100644
--- a/src/libs/languageserverprotocol/languagefeatures.h
+++ b/src/libs/languageserverprotocol/languagefeatures.h
@@ -72,7 +72,7 @@ public:
     HoverContent content() const;
     void setContent(const HoverContent &content);
 
-    Utils::optional<Range> range() const { return optionalValue<Range>(rangeKey); }
+    std::optional<Range> range() const { return optionalValue<Range>(rangeKey); }
     void setRange(const Range &range) { insert(rangeKey, range); }
     void clearRange() { remove(rangeKey); }
 
@@ -109,7 +109,7 @@ public:
     QString label() const { return typedValue<QString>(labelKey); }
     void setLabel(const QString &label) { insert(labelKey, label); }
 
-    Utils::optional<MarkupOrString> documentation() const;
+    std::optional<MarkupOrString> documentation() const;
     void setDocumentation(const MarkupOrString &documentation)
     { insert(documentationKey, documentation.toJson()); }
     void clearDocumentation() { remove(documentationKey); }
@@ -127,13 +127,13 @@ class LANGUAGESERVERPROTOCOL_EXPORT SignatureInformation : public ParameterInfor
 public:
     using ParameterInformation::ParameterInformation;
 
-    Utils::optional<QList<ParameterInformation>> parameters() const
+    std::optional<QList<ParameterInformation>> parameters() const
     { return optionalArray<ParameterInformation>(parametersKey); }
     void setParameters(const QList<ParameterInformation> &parameters)
     { insertArray(parametersKey, parameters); }
     void clearParameters() { remove(parametersKey); }
 
-    Utils::optional<int> activeParameter() const { return optionalValue<int>(activeParameterKey); }
+    std::optional<int> activeParameter() const { return optionalValue<int>(activeParameterKey); }
     void setActiveParameter(int activeParameter) { insert(activeParameterKey, activeParameter); }
     void clearActiveParameter() { remove(activeParameterKey); }
 };
@@ -163,7 +163,7 @@ public:
      * In future version of the protocol this property might become
      * mandatory to better express this.
      */
-    Utils::optional<int> activeSignature() const { return optionalValue<int>(activeSignatureKey); }
+    std::optional<int> activeSignature() const { return optionalValue<int>(activeSignatureKey); }
     void setActiveSignature(int activeSignature) { insert(activeSignatureKey, activeSignature); }
     void clearActiveSignature() { remove(activeSignatureKey); }
 
@@ -176,7 +176,7 @@ public:
      * mandatory to better express the active parameter if the
      * active signature does have any.
      */
-    Utils::optional<int> activeParameter() const { return optionalValue<int>(activeParameterKey); }
+    std::optional<int> activeParameter() const { return optionalValue<int>(activeParameterKey); }
     void setActiveParameter(int activeParameter) { insert(activeParameterKey, activeParameter); }
     void clearActiveParameter() { remove(activeParameterKey); }
 
@@ -277,7 +277,7 @@ public:
     Range range() const { return typedValue<Range>(rangeKey); }
     void setRange(const Range &range) { insert(rangeKey, range); }
 
-    Utils::optional<int> kind() const { return optionalValue<int>(kindKey); }
+    std::optional<int> kind() const { return optionalValue<int>(kindKey); }
     void setKind(int kind) { insert(kindKey, kind); }
     void clearKind() { remove(kindKey); }
 
@@ -394,7 +394,7 @@ public:
         void setDiagnostics(const QList<Diagnostic> &diagnostics)
         { insertArray(diagnosticsKey, diagnostics); }
 
-        Utils::optional<QList<CodeActionKind>> only() const;
+        std::optional<QList<CodeActionKind>> only() const;
         void setOnly(const QList<CodeActionKind> &only);
         void clearOnly() { remove(onlyKey); }
 
@@ -424,21 +424,21 @@ public:
     QString title() const { return typedValue<QString>(titleKey); }
     void setTitle(QString title) { insert(titleKey, title); }
 
-    Utils::optional<CodeActionKind> kind() const { return optionalValue<CodeActionKind>(kindKey); }
+    std::optional<CodeActionKind> kind() const { return optionalValue<CodeActionKind>(kindKey); }
     void setKind(const CodeActionKind &kind) { insert(kindKey, kind); }
     void clearKind() { remove(kindKey); }
 
-    Utils::optional<QList<Diagnostic>> diagnostics() const
+    std::optional<QList<Diagnostic>> diagnostics() const
     { return optionalArray<Diagnostic>(diagnosticsKey); }
     void setDiagnostics(const QList<Diagnostic> &diagnostics)
     { insertArray(diagnosticsKey, diagnostics); }
     void clearDiagnostics() { remove(diagnosticsKey); }
 
-    Utils::optional<WorkspaceEdit> edit() const { return optionalValue<WorkspaceEdit>(editKey); }
+    std::optional<WorkspaceEdit> edit() const { return optionalValue<WorkspaceEdit>(editKey); }
     void setEdit(const WorkspaceEdit &edit) { insert(editKey, edit); }
     void clearEdit() { remove(editKey); }
 
-    Utils::optional<Command> command() const { return optionalValue<Command>(commandKey); }
+    std::optional<Command> command() const { return optionalValue<Command>(commandKey); }
     void setCommand(const Command &command) { insert(commandKey, command); }
     void clearCommand() { remove(commandKey); }
 
@@ -472,11 +472,11 @@ public:
     Range range() const { return typedValue<Range>(rangeKey); }
     void setRange(const Range &range) { insert(rangeKey, range); }
 
-    Utils::optional<Command> command() const { return optionalValue<Command>(commandKey); }
+    std::optional<Command> command() const { return optionalValue<Command>(commandKey); }
     void setCommand(const Command &command) { insert(commandKey, command); }
     void clearCommand() { remove(commandKey); }
 
-    Utils::optional<QJsonValue> data() const;
+    std::optional<QJsonValue> data() const;
     void setData(const QJsonValue &data) { insert(dataKey, data); }
     void clearData() { remove(dataKey); }
 
@@ -509,11 +509,11 @@ public:
     Range range() const { return typedValue<Range>(rangeKey); }
     void setRange(const Range &range) { insert(rangeKey, range); }
 
-    Utils::optional<DocumentUri> target() const;
+    std::optional<DocumentUri> target() const;
     void setTarget(const DocumentUri &target) { insert(targetKey, target.toString()); }
     void clearTarget() { remove(targetKey); }
 
-    Utils::optional<QJsonValue> data() const;
+    std::optional<QJsonValue> data() const;
     void setData(const QJsonValue &data) { insert(dataKey, data); }
     void clearData() { remove(dataKey); }
 
@@ -614,11 +614,11 @@ public:
     QString label() const { return typedValue<QString>(labelKey); }
     void setLabel(const QString &label) { insert(labelKey, label); }
 
-    Utils::optional<TextEdit> textEdit() const { return optionalValue<TextEdit>(textEditKey); }
+    std::optional<TextEdit> textEdit() const { return optionalValue<TextEdit>(textEditKey); }
     void setTextEdit(const TextEdit &textEdit) { insert(textEditKey, textEdit); }
     void clearTextEdit() { remove(textEditKey); }
 
-    Utils::optional<QList<TextEdit>> additionalTextEdits() const
+    std::optional<QList<TextEdit>> additionalTextEdits() const
     { return optionalArray<TextEdit>(additionalTextEditsKey); }
     void setAdditionalTextEdits(const QList<TextEdit> &additionalTextEdits)
     { insertArray(additionalTextEditsKey, additionalTextEdits); }
@@ -659,19 +659,19 @@ public:
     bool insertSpace() const { return typedValue<bool>(insertSpaceKey); }
     void setInsertSpace(bool insertSpace) { insert(insertSpaceKey, insertSpace); }
 
-    Utils::optional<bool> trimTrailingWhitespace() const
+    std::optional<bool> trimTrailingWhitespace() const
     { return optionalValue<bool>(trimTrailingWhitespaceKey); }
     void setTrimTrailingWhitespace(bool trimTrailingWhitespace)
     { insert(trimTrailingWhitespaceKey, trimTrailingWhitespace); }
     void clearTrimTrailingWhitespace() { remove(trimTrailingWhitespaceKey); }
 
-    Utils::optional<bool> insertFinalNewline() const
+    std::optional<bool> insertFinalNewline() const
     { return optionalValue<bool>(insertFinalNewlineKey); }
     void setInsertFinalNewline(bool insertFinalNewline)
     { insert(insertFinalNewlineKey, insertFinalNewline); }
     void clearInsertFinalNewline() { remove(insertFinalNewlineKey); }
 
-    Utils::optional<bool> trimFinalNewlines() const
+    std::optional<bool> trimFinalNewlines() const
     { return optionalValue<bool>(trimFinalNewlinesKey); }
     void setTrimFinalNewlines(bool trimFinalNewlines)
     { insert(trimFinalNewlinesKey, trimFinalNewlines); }
diff --git a/src/libs/languageserverprotocol/lsptypes.cpp b/src/libs/languageserverprotocol/lsptypes.cpp
index 7db90d6fe7..c2810c9520 100644
--- a/src/libs/languageserverprotocol/lsptypes.cpp
+++ b/src/libs/languageserverprotocol/lsptypes.cpp
@@ -17,24 +17,24 @@
 
 namespace LanguageServerProtocol {
 
-Utils::optional<DiagnosticSeverity> Diagnostic::severity() const
+std::optional<DiagnosticSeverity> Diagnostic::severity() const
 {
     if (auto val = optionalValue<int>(severityKey))
-        return Utils::make_optional(static_cast<DiagnosticSeverity>(*val));
-    return Utils::nullopt;
+        return std::make_optional(static_cast<DiagnosticSeverity>(*val));
+    return std::nullopt;
 }
 
-Utils::optional<Diagnostic::Code> Diagnostic::code() const
+std::optional<Diagnostic::Code> Diagnostic::code() const
 {
     QJsonValue codeValue = value(codeKey);
     auto it = find(codeKey);
     if (codeValue.isUndefined())
-        return Utils::nullopt;
+        return std::nullopt;
     QJsonValue::Type type = it.value().type();
     if (type != QJsonValue::String && type != QJsonValue::Double)
-        return Utils::make_optional(Code(QString()));
-    return Utils::make_optional(codeValue.isDouble() ? Code(codeValue.toInt())
-                                                     : Code(codeValue.toString()));
+        return std::make_optional(Code(QString()));
+    return std::make_optional(codeValue.isDouble() ? Code(codeValue.toInt())
+                                                   : Code(codeValue.toString()));
 }
 
 void Diagnostic::setCode(const Diagnostic::Code &code)
@@ -42,16 +42,16 @@ void Diagnostic::setCode(const Diagnostic::Code &code)
     insertVariant<int, QString>(codeKey, code);
 }
 
-Utils::optional<WorkspaceEdit::Changes> WorkspaceEdit::changes() const
+std::optional<WorkspaceEdit::Changes> WorkspaceEdit::changes() const
 {
     auto it = find(changesKey);
     if (it == end())
-        return Utils::nullopt;
+        return std::nullopt;
     const QJsonObject &changesObject = it.value().toObject();
     Changes changesResult;
     for (const QString &key : changesObject.keys())
         changesResult[DocumentUri::fromProtocol(key)] = LanguageClientArray<TextEdit>(changesObject.value(key)).toList();
-    return Utils::make_optional(changesResult);
+    return std::make_optional(changesResult);
 }
 
 void WorkspaceEdit::setChanges(const Changes &changes)
@@ -325,7 +325,7 @@ QString expressionForGlob(QString globPattern)
 
 bool DocumentFilter::applies(const Utils::FilePath &fileName, const Utils::MimeType &mimeType) const
 {
-    if (Utils::optional<QString> _pattern = pattern()) {
+    if (std::optional<QString> _pattern = pattern()) {
         QRegularExpression::PatternOption option = QRegularExpression::NoPatternOption;
         if (fileName.caseSensitivity() == Qt::CaseInsensitive)
             option = QRegularExpression::CaseInsensitiveOption;
@@ -333,7 +333,7 @@ bool DocumentFilter::applies(const Utils::FilePath &fileName, const Utils::MimeT
         if (regexp.isValid() && regexp.match(fileName.toString()).hasMatch())
             return true;
     }
-    if (Utils::optional<QString> _lang = language()) {
+    if (std::optional<QString> _lang = language()) {
         auto match = [&_lang](const Utils::MimeType &mimeType){
             return *_lang == TextDocumentItem::mimeTypeToLanguageId(mimeType);
         };
diff --git a/src/libs/languageserverprotocol/lsptypes.h b/src/libs/languageserverprotocol/lsptypes.h
index d65e30b869..0c848130ce 100644
--- a/src/libs/languageserverprotocol/lsptypes.h
+++ b/src/libs/languageserverprotocol/lsptypes.h
@@ -10,7 +10,6 @@
 #include <utils/filepath.h>
 #include <utils/link.h>
 #include <utils/mimeutils.h>
-#include <utils/optional.h>
 #include <utils/textutils.h>
 
 #include <QTextCursor>
@@ -19,6 +18,7 @@
 #include <QList>
 
 #include <functional>
+#include <optional>
 #include <variant>
 
 namespace LanguageServerProtocol {
@@ -162,20 +162,20 @@ public:
 
     // The diagnostic's severity. Can be omitted. If omitted it is up to the
     // client to interpret diagnostics as error, warning, info or hint.
-    Utils::optional<DiagnosticSeverity> severity() const;
+    std::optional<DiagnosticSeverity> severity() const;
     void setSeverity(const DiagnosticSeverity &severity)
     { insert(severityKey, static_cast<int>(severity)); }
     void clearSeverity() { remove(severityKey); }
 
     // The diagnostic's code, which might appear in the user interface.
     using Code = std::variant<int, QString>;
-    Utils::optional<Code> code() const;
+    std::optional<Code> code() const;
     void setCode(const Code &code);
     void clearCode() { remove(codeKey); }
 
     // A human-readable string describing the source of this
     // diagnostic, e.g. 'typescript' or 'super lint'.
-    Utils::optional<QString> source() const
+    std::optional<QString> source() const
     { return optionalValue<QString>(sourceKey); }
     void setSource(const QString &source) { insert(sourceKey, source); }
     void clearSource() { remove(sourceKey); }
@@ -204,7 +204,7 @@ public:
     void clearCommand() { remove(commandKey); }
 
     // Arguments that the command handler should be invoked with.
-    Utils::optional<QJsonArray> arguments() const { return typedValue<QJsonArray>(argumentsKey); }
+    std::optional<QJsonArray> arguments() const { return typedValue<QJsonArray>(argumentsKey); }
     void setArguments(const QJsonArray &arguments) { insert(argumentsKey, arguments); }
     void clearArguments() { remove(argumentsKey); }
 
@@ -291,7 +291,7 @@ public:
 
     // Holds changes to existing resources.
     using Changes = QMap<DocumentUri, QList<TextEdit>>;
-    Utils::optional<Changes> changes() const;
+    std::optional<Changes> changes() const;
     void setChanges(const Changes &changes);
 
     /*
@@ -303,7 +303,7 @@ public:
      * Note: If the client can handle versioned document edits and if documentChanges are present,
      * the latter are preferred over changes.
      */
-    Utils::optional<QList<TextDocumentEdit>> documentChanges() const
+    std::optional<QList<TextDocumentEdit>> documentChanges() const
     { return optionalArray<TextDocumentEdit>(documentChangesKey); }
     void setDocumentChanges(const QList<TextDocumentEdit> &changes)
     { insertArray(documentChangesKey, changes); }
@@ -363,12 +363,12 @@ public:
     using JsonObject::JsonObject;
 
     // A language id, like `typescript`.
-    Utils::optional<QString> language() const { return optionalValue<QString>(languageKey); }
+    std::optional<QString> language() const { return optionalValue<QString>(languageKey); }
     void setLanguage(const QString &language) { insert(languageKey, language); }
     void clearLanguage() { remove(languageKey); }
 
     // A Uri [scheme](#Uri.scheme), like `file` or `untitled`.
-    Utils::optional<QString> scheme() const { return optionalValue<QString>(schemeKey); }
+    std::optional<QString> scheme() const { return optionalValue<QString>(schemeKey); }
     void setScheme(const QString &scheme) { insert(schemeKey, scheme); }
     void clearScheme() { remove(schemeKey); }
 
@@ -387,7 +387,7 @@ public:
      *   (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but
      *   not `example.0`)
      */
-    Utils::optional<QString> pattern() const { return optionalValue<QString>(patternKey); }
+    std::optional<QString> pattern() const { return optionalValue<QString>(patternKey); }
     void setPattern(const QString &pattern) { insert(patternKey, pattern); }
     void clearPattern() { remove(patternKey); }
 
@@ -478,14 +478,14 @@ public:
     int kind() const { return typedValue<int>(kindKey); }
     void setKind(int kind) { insert(kindKey, kind); }
 
-    Utils::optional<bool> deprecated() const { return optionalValue<bool>(deprecatedKey); }
+    std::optional<bool> deprecated() const { return optionalValue<bool>(deprecatedKey); }
     void setDeprecated(bool deprecated) { insert(deprecatedKey, deprecated); }
     void clearDeprecated() { remove(deprecatedKey); }
 
     Location location() const { return typedValue<Location>(locationKey); }
     void setLocation(const Location &location) { insert(locationKey, location); }
 
-    Utils::optional<QString> containerName() const
+    std::optional<QString> containerName() const
     { return optionalValue<QString>(containerNameKey); }
     void setContainerName(const QString &containerName) { insert(containerNameKey, containerName); }
     void clearContainerName() { remove(containerNameKey); }
@@ -502,14 +502,14 @@ public:
     QString name() const { return typedValue<QString>(nameKey); }
     void setName(const QString &name) { insert(nameKey, name); }
 
-    Utils::optional<QString> detail() const { return optionalValue<QString>(detailKey); }
+    std::optional<QString> detail() const { return optionalValue<QString>(detailKey); }
     void setDetail(const QString &detail) { insert(detailKey, detail); }
     void clearDetail() { remove(detailKey); }
 
     int kind() const { return typedValue<int>(kindKey); }
     void setKind(int kind) { insert(kindKey, kind); }
 
-    Utils::optional<bool> deprecated() const { return optionalValue<bool>(deprecatedKey); }
+    std::optional<bool> deprecated() const { return optionalValue<bool>(deprecatedKey); }
     void setDeprecated(bool deprecated) { insert(deprecatedKey, deprecated); }
     void clearDeprecated() { remove(deprecatedKey); }
 
@@ -519,7 +519,7 @@ public:
     Range selectionRange() const { return typedValue<Range>(selectionRangeKey); }
     void setSelectionRange(Range selectionRange) { insert(selectionRangeKey, selectionRange); }
 
-    Utils::optional<QList<DocumentSymbol>> children() const
+    std::optional<QList<DocumentSymbol>> children() const
     { return optionalArray<DocumentSymbol>(childrenKey); }
     void setChildren(QList<DocumentSymbol> children) { insertArray(childrenKey, children); }
     void clearChildren() { remove(childrenKey); }
diff --git a/src/libs/languageserverprotocol/lsputils.h b/src/libs/languageserverprotocol/lsputils.h
index 8e2af619cc..874bc0bc98 100644
--- a/src/libs/languageserverprotocol/lsputils.h
+++ b/src/libs/languageserverprotocol/lsputils.h
@@ -6,13 +6,13 @@
 #include "languageserverprotocol_global.h"
 
 #include <utils/algorithm.h>
-#include <utils/optional.h>
 #include <utils/qtcassert.h>
 
 #include <QJsonArray>
 #include <QJsonObject>
 #include <QLoggingCategory>
 
+#include <optional>
 #include <variant>
 
 namespace LanguageServerProtocol {
diff --git a/src/libs/languageserverprotocol/messages.h b/src/libs/languageserverprotocol/messages.h
index f1c38f9cab..a6dde81c6e 100644
--- a/src/libs/languageserverprotocol/messages.h
+++ b/src/libs/languageserverprotocol/messages.h
@@ -55,7 +55,7 @@ class LANGUAGESERVERPROTOCOL_EXPORT ShowMessageRequestParams : public ShowMessag
 public:
     using ShowMessageParams::ShowMessageParams;
 
-    Utils::optional<QList<MessageActionItem>> actions() const
+    std::optional<QList<MessageActionItem>> actions() const
     { return optionalArray<MessageActionItem>(actionsKey); }
     void setActions(const QList<MessageActionItem> &actions) { insertArray(actionsKey, actions); }
     void clearActions() { remove(actionsKey); }
diff --git a/src/libs/languageserverprotocol/progresssupport.h b/src/libs/languageserverprotocol/progresssupport.h
index 6c3180adba..d07b894729 100644
--- a/src/libs/languageserverprotocol/progresssupport.h
+++ b/src/libs/languageserverprotocol/progresssupport.h
@@ -31,7 +31,7 @@ public:
      * long running operation.
      * Clients that don't support cancellation can ignore the setting.
      */
-    Utils::optional<bool> cancellable() const { return optionalValue<bool>(cancellableKey); }
+    std::optional<bool> cancellable() const { return optionalValue<bool>(cancellableKey); }
     void setCancellable(bool cancellable) { insert(cancellableKey, cancellable); }
     void clearCancellable() { remove(cancellableKey); }
 
@@ -42,7 +42,7 @@ public:
      * Examples: "3/25 files", "project/src/module2", "node_modules/some_dep".
      * If unset, the previous progress message (if any) is still valid.
      */
-    Utils::optional<QString> message() const { return optionalValue<QString>(messageKey); }
+    std::optional<QString> message() const { return optionalValue<QString>(messageKey); }
     void setMessage(const QString &message) { insert(messageKey, message); }
     void clearMessage() { remove(messageKey); }
 
@@ -58,7 +58,7 @@ public:
     // Allthough percentage is defined as an uint by the protocol some server
     // return a double here. Be less strict and also use a double.
     // CAUTION: the range is still 0 - 100 and not 0 - 1
-    Utils::optional<double> percentage() const { return optionalValue<double>(percentageKey); }
+    std::optional<double> percentage() const { return optionalValue<double>(percentageKey); }
     void setPercentage(double percentage) { insert(percentageKey, percentage); }
     void clearPercentage() { remove(percentageKey); }
 };
@@ -88,7 +88,7 @@ public:
      * Optional, a final message indicating to for example indicate the outcome
      * of the operation.
      */
-    Utils::optional<QString> message() const { return optionalValue<QString>(messageKey); }
+    std::optional<QString> message() const { return optionalValue<QString>(messageKey); }
     void setMessage(const QString &message) { insert(messageKey, message); }
     void clearMessage() { remove(messageKey); }
 };
diff --git a/src/libs/languageserverprotocol/semantictokens.h b/src/libs/languageserverprotocol/semantictokens.h
index 6025a6d683..6cc303b84f 100644
--- a/src/libs/languageserverprotocol/semantictokens.h
+++ b/src/libs/languageserverprotocol/semantictokens.h
@@ -125,7 +125,7 @@ public:
      * A server can then instead of computing all semantic tokens again simply
      * send a delta.
      */
-    Utils::optional<QString> resultId() const { return optionalValue<QString>(resultIdKey); }
+    std::optional<QString> resultId() const { return optionalValue<QString>(resultIdKey); }
     void setResultId(const QString &resultId) { insert(resultIdKey, resultId); }
     void clearResultId() { remove(resultIdKey); }
 
@@ -169,7 +169,7 @@ public:
     int deleteCount() const { return typedValue<int>(deleteCountKey); }
     void setDeleteCount(int deleteCount) { insert(deleteCountKey, deleteCount); }
 
-    Utils::optional<QList<int>> data() const { return optionalArray<int>(dataKey); }
+    std::optional<QList<int>> data() const { return optionalArray<int>(dataKey); }
     void setData(const QList<int> &value) { insertArray(dataKey, value); }
     void clearData() { remove(dataKey); }
 
diff --git a/src/libs/languageserverprotocol/servercapabilities.cpp b/src/libs/languageserverprotocol/servercapabilities.cpp
index 6ba697f5b3..1573f49285 100644
--- a/src/libs/languageserverprotocol/servercapabilities.cpp
+++ b/src/libs/languageserverprotocol/servercapabilities.cpp
@@ -5,13 +5,14 @@
 
 namespace LanguageServerProtocol {
 
-Utils::optional<ServerCapabilities::TextDocumentSync> ServerCapabilities::textDocumentSync() const
+std::optional<ServerCapabilities::TextDocumentSync> ServerCapabilities::textDocumentSync() const
 {
     const QJsonValue &sync = value(textDocumentSyncKey);
     if (sync.isUndefined())
-        return Utils::nullopt;
-    return Utils::make_optional(sync.isDouble() ? TextDocumentSync(sync.toInt())
-                                                : TextDocumentSync(TextDocumentSyncOptions(sync.toObject())));
+        return std::nullopt;
+    return std::make_optional(sync.isDouble()
+                                  ? TextDocumentSync(sync.toInt())
+                                  : TextDocumentSync(TextDocumentSyncOptions(sync.toObject())));
 }
 
 void ServerCapabilities::setTextDocumentSync(const ServerCapabilities::TextDocumentSync &textDocumentSync)
@@ -21,27 +22,27 @@ void ServerCapabilities::setTextDocumentSync(const ServerCapabilities::TextDocum
 
 TextDocumentSyncKind ServerCapabilities::textDocumentSyncKindHelper()
 {
-    if (Utils::optional<TextDocumentSync> sync = textDocumentSync()) {
+    if (std::optional<TextDocumentSync> sync = textDocumentSync()) {
         if (auto kind = std::get_if<int>(&*sync))
             return static_cast<TextDocumentSyncKind>(*kind);
         if (auto options = std::get_if<TextDocumentSyncOptions>(&*sync)) {
-            if (const Utils::optional<int> &change = options->change())
+            if (const std::optional<int> &change = options->change())
                 return static_cast<TextDocumentSyncKind>(*change);
         }
     }
     return TextDocumentSyncKind::None;
 }
 
-Utils::optional<std::variant<bool, WorkDoneProgressOptions>> ServerCapabilities::hoverProvider()
+std::optional<std::variant<bool, WorkDoneProgressOptions>> ServerCapabilities::hoverProvider()
     const
 {
     using RetType = std::variant<bool, WorkDoneProgressOptions>;
     const QJsonValue &provider = value(hoverProviderKey);
     if (provider.isBool())
-        return Utils::make_optional(RetType(provider.toBool()));
+        return std::make_optional(RetType(provider.toBool()));
     if (provider.isObject())
-        return Utils::make_optional(RetType(WorkDoneProgressOptions(provider.toObject())));
-    return Utils::nullopt;
+        return std::make_optional(RetType(WorkDoneProgressOptions(provider.toObject())));
+    return std::nullopt;
 }
 
 void ServerCapabilities::setHoverProvider(
@@ -50,15 +51,16 @@ void ServerCapabilities::setHoverProvider(
     insertVariant<bool, WorkDoneProgressOptions>(hoverProviderKey, hoverProvider);
 }
 
-Utils::optional<std::variant<bool, ServerCapabilities::RegistrationOptions>>
+std::optional<std::variant<bool, ServerCapabilities::RegistrationOptions>>
 ServerCapabilities::typeDefinitionProvider() const
 {
     using RetType = std::variant<bool, ServerCapabilities::RegistrationOptions>;
     const QJsonValue &provider = value(typeDefinitionProviderKey);
     if (provider.isUndefined() || !(provider.isBool() || provider.isObject()))
-        return Utils::nullopt;
-    return Utils::make_optional(provider.isBool() ? RetType(provider.toBool())
-                                                  : RetType(RegistrationOptions(provider.toObject())));
+        return std::nullopt;
+    return std::make_optional(provider.isBool()
+                                  ? RetType(provider.toBool())
+                                  : RetType(RegistrationOptions(provider.toObject())));
 }
 
 void ServerCapabilities::setTypeDefinitionProvider(
@@ -68,15 +70,16 @@ void ServerCapabilities::setTypeDefinitionProvider(
                                                                  typeDefinitionProvider);
 }
 
-Utils::optional<std::variant<bool, ServerCapabilities::RegistrationOptions>>
+std::optional<std::variant<bool, ServerCapabilities::RegistrationOptions>>
 ServerCapabilities::implementationProvider() const
 {
     using RetType = std::variant<bool, ServerCapabilities::RegistrationOptions>;
     const QJsonValue &provider = value(implementationProviderKey);
     if (provider.isUndefined() || !(provider.isBool() || provider.isObject()))
-        return Utils::nullopt;
-    return Utils::make_optional(provider.isBool() ? RetType(provider.toBool())
-                                                  : RetType(RegistrationOptions(provider.toObject())));
+        return std::nullopt;
+    return std::make_optional(provider.isBool()
+                                  ? RetType(provider.toBool())
+                                  : RetType(RegistrationOptions(provider.toObject())));
 }
 
 void ServerCapabilities::setImplementationProvider(
@@ -85,16 +88,16 @@ void ServerCapabilities::setImplementationProvider(
     insertVariant<bool, RegistrationOptions>(implementationProviderKey, implementationProvider);
 }
 
-Utils::optional<std::variant<bool, WorkDoneProgressOptions>>
+std::optional<std::variant<bool, WorkDoneProgressOptions>>
 ServerCapabilities::referencesProvider() const
 {
     using RetType = std::variant<bool, WorkDoneProgressOptions>;
     const QJsonValue &provider = value(referencesProviderKey);
     if (provider.isBool())
-        return Utils::make_optional(RetType(provider.toBool()));
+        return std::make_optional(RetType(provider.toBool()));
     if (provider.isObject())
-        return Utils::make_optional(RetType(WorkDoneProgressOptions(provider.toObject())));
-    return Utils::nullopt;
+        return std::make_optional(RetType(WorkDoneProgressOptions(provider.toObject())));
+    return std::nullopt;
 }
 
 void ServerCapabilities::setReferencesProvider(
@@ -104,16 +107,16 @@ void ServerCapabilities::setReferencesProvider(
                                                  referencesProvider);
 }
 
-Utils::optional<std::variant<bool, WorkDoneProgressOptions>>
+std::optional<std::variant<bool, WorkDoneProgressOptions>>
 ServerCapabilities::documentHighlightProvider() const
 {
     using RetType = std::variant<bool, WorkDoneProgressOptions>;
     const QJsonValue &provider = value(documentHighlightProviderKey);
     if (provider.isBool())
-        return Utils::make_optional(RetType(provider.toBool()));
+        return std::make_optional(RetType(provider.toBool()));
     if (provider.isObject())
-        return Utils::make_optional(RetType(WorkDoneProgressOptions(provider.toObject())));
-    return Utils::nullopt;
+        return std::make_optional(RetType(WorkDoneProgressOptions(provider.toObject())));
+    return std::nullopt;
 }
 
 void ServerCapabilities::setDocumentHighlightProvider(
@@ -123,16 +126,16 @@ void ServerCapabilities::setDocumentHighlightProvider(
                                                  documentHighlightProvider);
 }
 
-Utils::optional<std::variant<bool, WorkDoneProgressOptions>>
+std::optional<std::variant<bool, WorkDoneProgressOptions>>
 ServerCapabilities::documentSymbolProvider() const
 {
     using RetType = std::variant<bool, WorkDoneProgressOptions>;
     const QJsonValue &provider = value(documentSymbolProviderKey);
     if (provider.isBool())
-        return Utils::make_optional(RetType(provider.toBool()));
+        return std::make_optional(RetType(provider.toBool()));
     if (provider.isObject())
-        return Utils::make_optional(RetType(WorkDoneProgressOptions(provider.toObject())));
-    return Utils::nullopt;
+        return std::make_optional(RetType(WorkDoneProgressOptions(provider.toObject())));
+    return std::nullopt;
 }
 
 void ServerCapabilities::setDocumentSymbolProvider(
@@ -142,7 +145,7 @@ void ServerCapabilities::setDocumentSymbolProvider(
                                                  documentSymbolProvider);
 }
 
-Utils::optional<SemanticTokensOptions> ServerCapabilities::semanticTokensProvider() const
+std::optional<SemanticTokensOptions> ServerCapabilities::semanticTokensProvider() const
 {
     return optionalValue<SemanticTokensOptions>(semanticTokensProviderKey);
 }
@@ -153,16 +156,16 @@ void ServerCapabilities::setSemanticTokensProvider(
     insert(semanticTokensProviderKey, semanticTokensProvider);
 }
 
-Utils::optional<std::variant<bool, WorkDoneProgressOptions>>
+std::optional<std::variant<bool, WorkDoneProgressOptions>>
 ServerCapabilities::workspaceSymbolProvider() const
 {
     using RetType = std::variant<bool, WorkDoneProgressOptions>;
     const QJsonValue &provider = value(workspaceSymbolProviderKey);
     if (provider.isBool())
-        return Utils::make_optional(RetType(provider.toBool()));
+        return std::make_optional(RetType(provider.toBool()));
     if (provider.isObject())
-        return Utils::make_optional(RetType(WorkDoneProgressOptions(provider.toObject())));
-    return Utils::nullopt;
+        return std::make_optional(RetType(WorkDoneProgressOptions(provider.toObject())));
+    return std::nullopt;
 }
 
 void ServerCapabilities::setWorkspaceSymbolProvider(
@@ -172,29 +175,29 @@ void ServerCapabilities::setWorkspaceSymbolProvider(
                                                  workspaceSymbolProvider);
 }
 
-Utils::optional<std::variant<bool, CodeActionOptions>> ServerCapabilities::codeActionProvider() const
+std::optional<std::variant<bool, CodeActionOptions>> ServerCapabilities::codeActionProvider() const
 {
     const QJsonValue &provider = value(codeActionProviderKey);
     if (provider.isBool())
-        return Utils::make_optional(std::variant<bool, CodeActionOptions>(provider.toBool()));
+        return std::make_optional(std::variant<bool, CodeActionOptions>(provider.toBool()));
     if (provider.isObject()) {
         CodeActionOptions options(provider);
         if (options.isValid())
-            return Utils::make_optional(std::variant<bool, CodeActionOptions>(options));
+            return std::make_optional(std::variant<bool, CodeActionOptions>(options));
     }
-    return Utils::nullopt;
+    return std::nullopt;
 }
 
-Utils::optional<std::variant<bool, WorkDoneProgressOptions>>
+std::optional<std::variant<bool, WorkDoneProgressOptions>>
 ServerCapabilities::documentFormattingProvider() const
 {
     using RetType = std::variant<bool, WorkDoneProgressOptions>;
     const QJsonValue &provider = value(documentFormattingProviderKey);
     if (provider.isBool())
-        return Utils::make_optional(RetType(provider.toBool()));
+        return std::make_optional(RetType(provider.toBool()));
     if (provider.isObject())
-        return Utils::make_optional(RetType(WorkDoneProgressOptions(provider.toObject())));
-    return Utils::nullopt;
+        return std::make_optional(RetType(WorkDoneProgressOptions(provider.toObject())));
+    return std::nullopt;
 }
 
 void ServerCapabilities::setDocumentFormattingProvider(
@@ -204,16 +207,16 @@ void ServerCapabilities::setDocumentFormattingProvider(
                                                  documentFormattingProvider);
 }
 
-Utils::optional<std::variant<bool, WorkDoneProgressOptions>>
+std::optional<std::variant<bool, WorkDoneProgressOptions>>
 ServerCapabilities::documentRangeFormattingProvider() const
 {
     using RetType = std::variant<bool, WorkDoneProgressOptions>;
     const QJsonValue &provider = value(documentRangeFormattingProviderKey);
     if (provider.isBool())
-        return Utils::make_optional(RetType(provider.toBool()));
+        return std::make_optional(RetType(provider.toBool()));
     if (provider.isObject())
-        return Utils::make_optional(RetType(WorkDoneProgressOptions(provider.toObject())));
-    return Utils::nullopt;
+        return std::make_optional(RetType(WorkDoneProgressOptions(provider.toObject())));
+    return std::nullopt;
 }
 
 void ServerCapabilities::setDocumentRangeFormattingProvider(
@@ -223,7 +226,7 @@ void ServerCapabilities::setDocumentRangeFormattingProvider(
                                                  documentRangeFormattingProvider);
 }
 
-Utils::optional<std::variant<ServerCapabilities::RenameOptions, bool>> ServerCapabilities::renameProvider() const
+std::optional<std::variant<ServerCapabilities::RenameOptions, bool>> ServerCapabilities::renameProvider() const
 {
     using RetType = std::variant<ServerCapabilities::RenameOptions, bool>;
     const QJsonValue &localValue = value(renameProviderKey);
@@ -231,7 +234,7 @@ Utils::optional<std::variant<ServerCapabilities::RenameOptions, bool>> ServerCap
         return RetType(localValue.toBool());
     if (localValue.isObject())
         return RetType(RenameOptions(localValue.toObject()));
-    return Utils::nullopt;
+    return std::nullopt;
 }
 
 void ServerCapabilities::setRenameProvider(std::variant<ServerCapabilities::RenameOptions, bool> renameProvider)
@@ -239,7 +242,7 @@ void ServerCapabilities::setRenameProvider(std::variant<ServerCapabilities::Rena
     insertVariant<RenameOptions, bool>(renameProviderKey, renameProvider);
 }
 
-Utils::optional<std::variant<bool, JsonObject>> ServerCapabilities::colorProvider() const
+std::optional<std::variant<bool, JsonObject>> ServerCapabilities::colorProvider() const
 {
     using RetType = std::variant<bool, JsonObject>;
     const QJsonValue &localValue = value(colorProviderKey);
@@ -247,7 +250,7 @@ Utils::optional<std::variant<bool, JsonObject>> ServerCapabilities::colorProvide
         return RetType(localValue.toBool());
     if (localValue.isObject())
         return RetType(JsonObject(localValue.toObject()));
-    return Utils::nullopt;
+    return std::nullopt;
 }
 
 void ServerCapabilities::setColorProvider(std::variant<bool, JsonObject> colorProvider)
@@ -255,15 +258,15 @@ void ServerCapabilities::setColorProvider(std::variant<bool, JsonObject> colorPr
     insertVariant<bool, JsonObject>(renameProviderKey, colorProvider);
 }
 
-Utils::optional<std::variant<QString, bool> >
+std::optional<std::variant<QString, bool> >
 ServerCapabilities::WorkspaceServerCapabilities::WorkspaceFoldersCapabilities::changeNotifications() const
 {
     using RetType = std::variant<QString, bool>;
     const QJsonValue &change = value(changeNotificationsKey);
     if (change.isUndefined())
-        return Utils::nullopt;
-    return Utils::make_optional(change.isBool() ? RetType(change.toBool())
-                                                : RetType(change.toString()));
+        return std::nullopt;
+    return std::make_optional(change.isBool() ? RetType(change.toBool())
+                                              : RetType(change.toString()));
 }
 
 void ServerCapabilities::WorkspaceServerCapabilities::WorkspaceFoldersCapabilities::setChangeNotifications(
@@ -293,7 +296,7 @@ bool CodeActionOptions::isValid() const
     return WorkDoneProgressOptions::isValid() && contains(codeActionKindsKey);
 }
 
-Utils::optional<std::variant<bool, QJsonObject>> SemanticTokensOptions::range() const
+std::optional<std::variant<bool, QJsonObject>> SemanticTokensOptions::range() const
 {
     using RetType = std::variant<bool, QJsonObject>;
     const QJsonValue &rangeOptions = value(rangeKey);
@@ -301,7 +304,7 @@ Utils::optional<std::variant<bool, QJsonObject>> SemanticTokensOptions::range()
         return RetType(rangeOptions.toBool());
     if (rangeOptions.isObject())
         return RetType(rangeOptions.toObject());
-    return Utils::nullopt;
+    return std::nullopt;
 }
 
 void SemanticTokensOptions::setRange(const std::variant<bool, QJsonObject> &range)
@@ -309,7 +312,7 @@ void SemanticTokensOptions::setRange(const std::variant<bool, QJsonObject> &rang
     insertVariant<bool, QJsonObject>(rangeKey, range);
 }
 
-Utils::optional<std::variant<bool, SemanticTokensOptions::FullSemanticTokenOptions>>
+std::optional<std::variant<bool, SemanticTokensOptions::FullSemanticTokenOptions>>
 SemanticTokensOptions::full() const
 {
     using RetType = std::variant<bool, SemanticTokensOptions::FullSemanticTokenOptions>;
@@ -318,7 +321,7 @@ SemanticTokensOptions::full() const
         return RetType(fullOptions.toBool());
     if (fullOptions.isObject())
         return RetType(FullSemanticTokenOptions(fullOptions.toObject()));
-    return Utils::nullopt;
+    return std::nullopt;
 }
 
 void SemanticTokensOptions::setFull(
diff --git a/src/libs/languageserverprotocol/servercapabilities.h b/src/libs/languageserverprotocol/servercapabilities.h
index c6cfe96ca6..35028760d1 100644
--- a/src/libs/languageserverprotocol/servercapabilities.h
+++ b/src/libs/languageserverprotocol/servercapabilities.h
@@ -13,7 +13,7 @@ class LANGUAGESERVERPROTOCOL_EXPORT WorkDoneProgressOptions : public JsonObject
 public:
     using JsonObject::JsonObject;
 
-    Utils::optional<bool> workDoneProgress() const { return optionalValue<bool>(workDoneProgressKey); }
+    std::optional<bool> workDoneProgress() const { return optionalValue<bool>(workDoneProgressKey); }
     void setWorkDoneProgress(bool workDoneProgress) { insert(workDoneProgressKey, workDoneProgress); }
     void clearWorkDoneProgress() { remove(workDoneProgressKey); }
 };
@@ -23,7 +23,7 @@ class LANGUAGESERVERPROTOCOL_EXPORT ResolveProviderOption : public JsonObject
 public:
     using JsonObject::JsonObject;
 
-    Utils::optional<bool> resolveProvider() const { return optionalValue<bool>(resolveProviderKey); }
+    std::optional<bool> resolveProvider() const { return optionalValue<bool>(resolveProviderKey); }
     void setResolveProvider(bool resolveProvider) { insert(resolveProviderKey, resolveProvider); }
     void clearResolveProvider() { remove(resolveProviderKey); }
 };
@@ -50,7 +50,7 @@ public:
     using JsonObject::JsonObject;
 
     // The client is supposed to include the content on save.
-    Utils::optional<bool> includeText() const { return optionalValue<bool>(includeTextKey); }
+    std::optional<bool> includeText() const { return optionalValue<bool>(includeTextKey); }
     void setIncludeText(bool includeText) { insert(includeTextKey, includeText); }
     void clearIncludeText() { remove(includeTextKey); }
 };
@@ -61,30 +61,30 @@ public:
     using JsonObject::JsonObject;
 
     // Open and close notifications are sent to the server.
-    Utils::optional<bool> openClose() const { return optionalValue<bool>(openCloseKey); }
+    std::optional<bool> openClose() const { return optionalValue<bool>(openCloseKey); }
     void setOpenClose(bool openClose) { insert(openCloseKey, openClose); }
     void clearOpenClose() { remove(openCloseKey); }
 
     // Change notifications are sent to the server. See TextDocumentSyncKind.None,
     // TextDocumentSyncKind.Full and TextDocumentSyncKind.Incremental.
-    Utils::optional<int> change() const { return optionalValue<int>(changeKey); }
+    std::optional<int> change() const { return optionalValue<int>(changeKey); }
     void setChange(int change) { insert(changeKey, change); }
     void clearChange() { remove(changeKey); }
 
     // Will save notifications are sent to the server.
-    Utils::optional<bool> willSave() const { return optionalValue<bool>(willSaveKey); }
+    std::optional<bool> willSave() const { return optionalValue<bool>(willSaveKey); }
     void setWillSave(bool willSave) { insert(willSaveKey, willSave); }
     void clearWillSave() { remove(willSaveKey); }
 
     // Will save wait until requests are sent to the server.
-    Utils::optional<bool> willSaveWaitUntil() const
+    std::optional<bool> willSaveWaitUntil() const
     { return optionalValue<bool>(willSaveWaitUntilKey); }
     void setWillSaveWaitUntil(bool willSaveWaitUntil)
     { insert(willSaveWaitUntilKey, willSaveWaitUntil); }
     void clearWillSaveWaitUntil() { remove(willSaveWaitUntilKey); }
 
     // Save notifications are sent to the server.
-    Utils::optional<SaveOptions> save() const { return optionalValue<SaveOptions>(saveKey); }
+    std::optional<SaveOptions> save() const { return optionalValue<SaveOptions>(saveKey); }
     void setSave(const SaveOptions &save) { insert(saveKey, save); }
     void clearSave() { remove(saveKey); }
 };
@@ -130,7 +130,7 @@ public:
     void setLegend(const SemanticTokensLegend &legend) { insert(legendKey, legend); }
 
     /// Server supports providing semantic tokens for a specific range of a document.
-    Utils::optional<std::variant<bool, QJsonObject>> range() const;
+    std::optional<std::variant<bool, QJsonObject>> range() const;
     void setRange(const std::variant<bool, QJsonObject> &range);
     void clearRange() { remove(rangeKey); }
 
@@ -140,13 +140,13 @@ public:
         using JsonObject::JsonObject;
 
         /// The server supports deltas for full documents.
-        Utils::optional<bool> delta() const { return optionalValue<bool>(deltaKey); }
+        std::optional<bool> delta() const { return optionalValue<bool>(deltaKey); }
         void setDelta(bool delta) { insert(deltaKey, delta); }
         void clearDelta() { remove(deltaKey); }
     };
 
     /// Server supports providing semantic tokens for a full document.
-    Utils::optional<std::variant<bool, FullSemanticTokenOptions>> full() const;
+    std::optional<std::variant<bool, FullSemanticTokenOptions>> full() const;
     void setFull(const std::variant<bool, FullSemanticTokenOptions> &full);
     void clearFull() { remove(fullKey); }
 
@@ -168,13 +168,13 @@ public:
         using WorkDoneProgressOptions::WorkDoneProgressOptions;
 
         // The characters that trigger completion automatically.
-        Utils::optional<QList<QString>> triggerCharacters() const
+        std::optional<QList<QString>> triggerCharacters() const
         { return optionalArray<QString>(triggerCharactersKey); }
         void setTriggerCharacters(const QList<QString> &triggerCharacters)
         { insertArray(triggerCharactersKey, triggerCharacters); }
         void clearTriggerCharacters() { remove(triggerCharactersKey); }
 
-        Utils::optional<bool> resolveProvider() const { return optionalValue<bool>(resolveProviderKey); }
+        std::optional<bool> resolveProvider() const { return optionalValue<bool>(resolveProviderKey); }
         void setResolveProvider(bool resolveProvider) { insert(resolveProviderKey, resolveProvider); }
         void clearResolveProvider() { remove(resolveProviderKey); }
     };
@@ -185,7 +185,7 @@ public:
         using WorkDoneProgressOptions::WorkDoneProgressOptions;
 
         // The characters that trigger signature help automatically.
-        Utils::optional<QList<QString>> triggerCharacters() const
+        std::optional<QList<QString>> triggerCharacters() const
         { return optionalArray<QString>(triggerCharactersKey); }
         void setTriggerCharacters(const QList<QString> &triggerCharacters)
         { insertArray(triggerCharactersKey, triggerCharacters); }
@@ -205,7 +205,7 @@ public:
         { insert(firstTriggerCharacterKey, firstTriggerCharacter); }
 
         // More trigger characters.
-        Utils::optional<QList<QString>> moreTriggerCharacter() const
+        std::optional<QList<QString>> moreTriggerCharacter() const
         { return optionalArray<QString>(moreTriggerCharacterKey); }
         void setMoreTriggerCharacter(const QList<QString> &moreTriggerCharacter)
         { insertArray(moreTriggerCharacterKey, moreTriggerCharacter); }
@@ -236,7 +236,7 @@ public:
 
         // The id used to register the request. The id can be used to deregister
         // the request again. See also Registration#id.
-        Utils::optional<QString> id() const { return optionalValue<QString>(idKey); }
+        std::optional<QString> id() const { return optionalValue<QString>(idKey); }
         void setId(const QString &id) { insert(idKey, id); }
         void clearId() { remove(idKey); }
     };
@@ -244,33 +244,33 @@ public:
     // Defines how text documents are synced. Is either a detailed structure defining each
     // notification or for backwards compatibility the TextDocumentSyncKind number.
     using TextDocumentSync = std::variant<TextDocumentSyncOptions, int>;
-    Utils::optional<TextDocumentSync> textDocumentSync() const;
+    std::optional<TextDocumentSync> textDocumentSync() const;
     void setTextDocumentSync(const TextDocumentSync &textDocumentSync);
     void clearTextDocumentSync() { remove(textDocumentSyncKey); }
 
     TextDocumentSyncKind textDocumentSyncKindHelper();
 
     // The server provides hover support.
-    Utils::optional<std::variant<bool, WorkDoneProgressOptions>> hoverProvider() const;
+    std::optional<std::variant<bool, WorkDoneProgressOptions>> hoverProvider() const;
     void setHoverProvider(const std::variant<bool, WorkDoneProgressOptions> &hoverProvider);
     void clearHoverProvider() { remove(hoverProviderKey); }
 
     // The server provides completion support.
-    Utils::optional<CompletionOptions> completionProvider() const
+    std::optional<CompletionOptions> completionProvider() const
     { return optionalValue<CompletionOptions>(completionProviderKey); }
     void setCompletionProvider(const CompletionOptions &completionProvider)
     { insert(completionProviderKey, completionProvider); }
     void clearCompletionProvider() { remove(completionProviderKey); }
 
     // The server provides signature help support.
-    Utils::optional<SignatureHelpOptions> signatureHelpProvider() const
+    std::optional<SignatureHelpOptions> signatureHelpProvider() const
     { return optionalValue<SignatureHelpOptions>(signatureHelpProviderKey); }
     void setSignatureHelpProvider(const SignatureHelpOptions &signatureHelpProvider)
     { insert(signatureHelpProviderKey, signatureHelpProvider); }
     void clearSignatureHelpProvider() { remove(signatureHelpProviderKey); }
 
     // The server provides goto definition support.
-    Utils::optional<bool> definitionProvider() const
+    std::optional<bool> definitionProvider() const
     { return optionalValue<bool>(definitionProviderKey); }
     void setDefinitionProvider(bool definitionProvider)
     { insert(definitionProviderKey, definitionProvider); }
@@ -291,7 +291,7 @@ public:
 
         // The id used to register the request. The id can be used to deregister
         // the request again. See also Registration#id.
-        Utils::optional<QString> id() const { return optionalValue<QString>(idKey); }
+        std::optional<QString> id() const { return optionalValue<QString>(idKey); }
         void setId(const QString &id) { insert(idKey, id); }
         void clearId() { remove(idKey); }
 
@@ -299,42 +299,42 @@ public:
     };
 
     // The server provides Goto Type Definition support.
-    Utils::optional<std::variant<bool, RegistrationOptions>> typeDefinitionProvider() const;
+    std::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<std::variant<bool, RegistrationOptions>> implementationProvider() const;
+    std::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<std::variant<bool, WorkDoneProgressOptions>> referencesProvider() const;
+    std::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<std::variant<bool, WorkDoneProgressOptions>> documentHighlightProvider() const;
+    std::optional<std::variant<bool, WorkDoneProgressOptions>> documentHighlightProvider() const;
     void setDocumentHighlightProvider(
         const std::variant<bool, WorkDoneProgressOptions> &documentHighlightProvider);
     void clearDocumentHighlightProvider() { remove(documentHighlightProviderKey); }
 
     // The server provides document symbol support.
-    Utils::optional<std::variant<bool, WorkDoneProgressOptions>> documentSymbolProvider() const;
+    std::optional<std::variant<bool, WorkDoneProgressOptions>> documentSymbolProvider() const;
     void setDocumentSymbolProvider(std::variant<bool, WorkDoneProgressOptions> documentSymbolProvider);
     void clearDocumentSymbolProvider() { remove(documentSymbolProviderKey); }
 
-    Utils::optional<SemanticTokensOptions> semanticTokensProvider() const;
+    std::optional<SemanticTokensOptions> semanticTokensProvider() const;
     void setSemanticTokensProvider(const SemanticTokensOptions &semanticTokensProvider);
     void clearSemanticTokensProvider() { remove(semanticTokensProviderKey); }
 
     // The server provides workspace symbol support.
-    Utils::optional<std::variant<bool, WorkDoneProgressOptions>> workspaceSymbolProvider() const;
+    std::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<std::variant<bool, CodeActionOptions>> codeActionProvider() const;
+    std::optional<std::variant<bool, CodeActionOptions>> codeActionProvider() const;
     void setCodeActionProvider(bool codeActionProvider)
     { insert(codeActionProviderKey, codeActionProvider); }
     void setCodeActionProvider(CodeActionOptions options)
@@ -342,20 +342,20 @@ public:
     void clearCodeActionProvider() { remove(codeActionProviderKey); }
 
     // The server provides code lens.
-    Utils::optional<CodeLensOptions> codeLensProvider() const
+    std::optional<CodeLensOptions> codeLensProvider() const
     { return optionalValue<CodeLensOptions>(codeLensProviderKey); }
     void setCodeLensProvider(CodeLensOptions codeLensProvider)
     { insert(codeLensProviderKey, codeLensProvider); }
     void clearCodeLensProvider() { remove(codeLensProviderKey); }
 
     // The server provides document formatting.
-    Utils::optional<std::variant<bool, WorkDoneProgressOptions>> documentFormattingProvider() const;
+    std::optional<std::variant<bool, WorkDoneProgressOptions>> documentFormattingProvider() const;
     void setDocumentFormattingProvider(
         const std::variant<bool, WorkDoneProgressOptions> &documentFormattingProvider);
     void clearDocumentFormattingProvider() { remove(documentFormattingProviderKey); }
 
     // The server provides document formatting on typing.
-    Utils::optional<std::variant<bool, WorkDoneProgressOptions>> documentRangeFormattingProvider() const;
+    std::optional<std::variant<bool, WorkDoneProgressOptions>> documentRangeFormattingProvider() const;
     void setDocumentRangeFormattingProvider(std::variant<bool, WorkDoneProgressOptions> documentRangeFormattingProvider);
     void clearDocumentRangeFormattingProvider() { remove(documentRangeFormattingProviderKey); }
 
@@ -365,30 +365,30 @@ public:
         using WorkDoneProgressOptions::WorkDoneProgressOptions;
 
         // Renames should be checked and tested before being executed.
-        Utils::optional<bool> prepareProvider() const { return optionalValue<bool>(prepareProviderKey); }
+        std::optional<bool> prepareProvider() const { return optionalValue<bool>(prepareProviderKey); }
         void setPrepareProvider(bool prepareProvider) { insert(prepareProviderKey, prepareProvider); }
         void clearPrepareProvider() { remove(prepareProviderKey); }
     };
 
     // The server provides rename support.
-    Utils::optional<std::variant<RenameOptions, bool>> renameProvider() const;
+    std::optional<std::variant<RenameOptions, bool>> renameProvider() const;
     void setRenameProvider(std::variant<RenameOptions,bool> renameProvider);
     void clearRenameProvider() { remove(renameProviderKey); }
 
     // The server provides document link support.
-    Utils::optional<DocumentLinkOptions> documentLinkProvider() const
+    std::optional<DocumentLinkOptions> documentLinkProvider() const
     { return optionalValue<DocumentLinkOptions>(documentLinkProviderKey); }
     void setDocumentLinkProvider(const DocumentLinkOptions &documentLinkProvider)
     { insert(documentLinkProviderKey, documentLinkProvider); }
     void clearDocumentLinkProvider() { remove(documentLinkProviderKey); }
 
     // The server provides color provider support.
-    Utils::optional<std::variant<bool, JsonObject>> colorProvider() const;
+    std::optional<std::variant<bool, JsonObject>> colorProvider() const;
     void setColorProvider(std::variant<bool, JsonObject> colorProvider);
     void clearColorProvider() { remove(colorProviderKey); }
 
     // The server provides execute command support.
-    Utils::optional<ExecuteCommandOptions> executeCommandProvider() const
+    std::optional<ExecuteCommandOptions> executeCommandProvider() const
     { return optionalValue<ExecuteCommandOptions>(executeCommandProviderKey); }
     void setExecuteCommandProvider(ExecuteCommandOptions executeCommandProvider)
     { insert(executeCommandProviderKey, executeCommandProvider); }
@@ -405,29 +405,29 @@ public:
             using JsonObject::JsonObject;
 
             // The server has support for workspace folders
-            Utils::optional<bool> supported() const { return optionalValue<bool>(supportedKey); }
+            std::optional<bool> supported() const { return optionalValue<bool>(supportedKey); }
             void setSupported(bool supported) { insert(supportedKey, supported); }
             void clearSupported() { remove(supportedKey); }
 
-            Utils::optional<std::variant<QString, bool>> changeNotifications() const;
+            std::optional<std::variant<QString, bool>> changeNotifications() const;
             void setChangeNotifications(std::variant<QString, bool> changeNotifications);
             void clearChangeNotifications() { remove(changeNotificationsKey); }
         };
 
-        Utils::optional<WorkspaceFoldersCapabilities> workspaceFolders() const
+        std::optional<WorkspaceFoldersCapabilities> workspaceFolders() const
         { return optionalValue<WorkspaceFoldersCapabilities>(workspaceFoldersKey); }
         void setWorkspaceFolders(const WorkspaceFoldersCapabilities &workspaceFolders)
         { insert(workspaceFoldersKey, workspaceFolders); }
         void clearWorkspaceFolders() { remove(workspaceFoldersKey); }
     };
 
-    Utils::optional<WorkspaceServerCapabilities> workspace() const
+    std::optional<WorkspaceServerCapabilities> workspace() const
     { return optionalValue<WorkspaceServerCapabilities>(workspaceKey); }
     void setWorkspace(const WorkspaceServerCapabilities &workspace)
     { insert(workspaceKey, workspace); }
     void clearWorkspace() { remove(workspaceKey); }
 
-    Utils::optional<JsonObject> experimental() const { return optionalValue<JsonObject>(experimentalKey); }
+    std::optional<JsonObject> experimental() const { return optionalValue<JsonObject>(experimentalKey); }
     void setExperimental(const JsonObject &experimental) { insert(experimentalKey, experimental); }
     void clearExperimental() { remove(experimentalKey); }
 };
diff --git a/src/libs/languageserverprotocol/textsynchronization.h b/src/libs/languageserverprotocol/textsynchronization.h
index ada8843872..2f77fb26af 100644
--- a/src/libs/languageserverprotocol/textsynchronization.h
+++ b/src/libs/languageserverprotocol/textsynchronization.h
@@ -70,12 +70,12 @@ public:
         using JsonObject::JsonObject;
 
         // The range of the document that changed.
-        Utils::optional<Range> range() const { return optionalValue<Range>(rangeKey); }
+        std::optional<Range> range() const { return optionalValue<Range>(rangeKey); }
         void setRange(Range range) { insert(rangeKey, range); }
         void clearRange() { remove(rangeKey); }
 
         // The length of the range that got replaced.
-        Utils::optional<int> rangeLength() const { return optionalValue<int>(rangeLengthKey); }
+        std::optional<int> rangeLength() const { return optionalValue<int>(rangeLengthKey); }
         void setRangeLength(int rangeLength) { insert(rangeLengthKey, rangeLength); }
         void clearRangeLength() { remove(rangeLengthKey); }
 
@@ -155,7 +155,7 @@ class LANGUAGESERVERPROTOCOL_EXPORT TextDocumentSaveRegistrationOptions
 public:
     using TextDocumentRegistrationOptions::TextDocumentRegistrationOptions;
 
-    Utils::optional<bool> includeText() const { return optionalValue<bool>(includeTextKey); }
+    std::optional<bool> includeText() const { return optionalValue<bool>(includeTextKey); }
     void setIncludeText(bool includeText) { insert(includeTextKey, includeText); }
     void clearIncludeText() { remove(includeTextKey); }
 };
@@ -172,7 +172,7 @@ public:
     void setTextDocument(TextDocumentIdentifier textDocument)
     { insert(textDocumentKey, textDocument); }
 
-    Utils::optional<QString> text() const { return optionalValue<QString>(textKey); }
+    std::optional<QString> text() const { return optionalValue<QString>(textKey); }
     void setText(const QString &text) { insert(textKey, text); }
     void clearText() { remove(textKey); }
 
diff --git a/src/libs/languageserverprotocol/workspace.h b/src/libs/languageserverprotocol/workspace.h
index 987a012515..158a6d948b 100644
--- a/src/libs/languageserverprotocol/workspace.h
+++ b/src/libs/languageserverprotocol/workspace.h
@@ -92,11 +92,11 @@ public:
     public:
         using JsonObject::JsonObject;
 
-        Utils::optional<QString> scopeUri() const { return optionalValue<QString>(scopeUriKey); }
+        std::optional<QString> scopeUri() const { return optionalValue<QString>(scopeUriKey); }
         void setScopeUri(const QString &scopeUri) { insert(scopeUriKey, scopeUri); }
         void clearScopeUri() { remove(scopeUriKey); }
 
-        Utils::optional<QString> section() const { return optionalValue<QString>(sectionKey); }
+        std::optional<QString> section() const { return optionalValue<QString>(sectionKey); }
         void setSection(const QString &section) { insert(sectionKey, section); }
         void clearSection() { remove(sectionKey); }
 
@@ -191,7 +191,7 @@ public:
     void setCommand(const QString &command) { insert(commandKey, command); }
     void clearCommand() { remove(commandKey); }
 
-    Utils::optional<QJsonArray> arguments() const { return typedValue<QJsonArray>(argumentsKey); }
+    std::optional<QJsonArray> arguments() const { return typedValue<QJsonArray>(argumentsKey); }
     void setArguments(const QJsonArray &arguments) { insert(argumentsKey, arguments); }
     void clearArguments() { remove(argumentsKey); }
 
@@ -212,7 +212,7 @@ class LANGUAGESERVERPROTOCOL_EXPORT ApplyWorkspaceEditParams : public JsonObject
 public:
     using JsonObject::JsonObject;
 
-    Utils::optional<QString> label() const { return optionalValue<QString>(labelKey); }
+    std::optional<QString> label() const { return optionalValue<QString>(labelKey); }
     void setLabel(const QString &label) { insert(labelKey, label); }
     void clearLabel() { remove(labelKey); }
 
diff --git a/src/libs/sqlite/sqlitealgorithms.h b/src/libs/sqlite/sqlitealgorithms.h
index bda904c0e8..9361be0b10 100644
--- a/src/libs/sqlite/sqlitealgorithms.h
+++ b/src/libs/sqlite/sqlitealgorithms.h
@@ -3,9 +3,9 @@
 
 #pragma once
 
-#include <utils/optional.h>
 #include <utils/smallstringview.h>
 
+#include <optional>
 #include <type_traits>
 
 namespace Sqlite {
@@ -34,7 +34,7 @@ void insertUpdateDelete(SqliteRange &&sqliteRange,
     auto endSqliteIterator = sqliteRange.end();
     auto currentValueIterator = values.begin();
     auto endValueIterator = values.end();
-    Utils::optional<std::decay_t<decltype(*currentValueIterator)>> lastValue;
+    std::optional<std::decay_t<decltype(*currentValueIterator)>> lastValue;
 
     while (true) {
         bool hasMoreValues = currentValueIterator != endValueIterator;
diff --git a/src/libs/sqlite/sqlitebasestatement.h b/src/libs/sqlite/sqlitebasestatement.h
index 6dba297282..236f5a0586 100644
--- a/src/libs/sqlite/sqlitebasestatement.h
+++ b/src/libs/sqlite/sqlitebasestatement.h
@@ -14,13 +14,13 @@
 
 #include <utils/smallstringvector.h>
 
-#include <utils/optional.h>
 #include <utils/span.h>
 
 #include <cstdint>
 #include <exception>
 #include <functional>
 #include <memory>
+#include <optional>
 #include <tuple>
 #include <type_traits>
 
@@ -225,12 +225,12 @@ public:
     auto optionalValue(const QueryTypes &...queryValues)
     {
         Resetter resetter{this};
-        Utils::optional<ResultType> resultValue;
+        std::optional<ResultType> resultValue;
 
         bindValues(queryValues...);
 
         if (BaseStatement::next())
-            resultValue = createOptionalValue<Utils::optional<ResultType>>();
+            resultValue = createOptionalValue<std::optional<ResultType>>();
 
         return resultValue;
     }
@@ -495,7 +495,7 @@ private:
     template<typename ResultOptionalType, int... ColumnIndices>
     ResultOptionalType createOptionalValue(std::integer_sequence<int, ColumnIndices...>)
     {
-        return ResultOptionalType(Utils::in_place, ValueGetter(*this, ColumnIndices)...);
+        return ResultOptionalType(std::in_place, ValueGetter(*this, ColumnIndices)...);
     }
 
     template<typename ResultOptionalType>
diff --git a/src/libs/utils/CMakeLists.txt b/src/libs/utils/CMakeLists.txt
index 59987e8270..4f4d1063df 100644
--- a/src/libs/utils/CMakeLists.txt
+++ b/src/libs/utils/CMakeLists.txt
@@ -4,7 +4,6 @@ add_qtc_library(Utils
     Qt5::Concurrent Qt5::Core Qt5::Network Qt5::Gui Qt5::Widgets
     Qt6Core5Compat
   SOURCES
-    ../3rdparty/optional/optional.hpp
     ../3rdparty/span/span.hpp
     QtConcurrentTools
     algorithm.h
@@ -103,7 +102,6 @@ add_qtc_library(Utils
     namevaluevalidator.cpp namevaluevalidator.h
     navigationtreeview.cpp navigationtreeview.h
     networkaccessmanager.cpp networkaccessmanager.h
-    optional.h
     osspecificaspects.h
     outputformat.h
     outputformatter.cpp outputformatter.h
diff --git a/src/libs/utils/algorithm.h b/src/libs/utils/algorithm.h
index c897353fcd..dd914103ee 100644
--- a/src/libs/utils/algorithm.h
+++ b/src/libs/utils/algorithm.h
@@ -4,7 +4,6 @@
 #pragma once
 
 #include "predicates.h"
-#include "optional.h"
 
 #include <qcompilerdetection.h> // for Q_REQUIRED_RESULT
 
@@ -22,6 +21,7 @@
 #include <QStringList>
 
 #include <memory>
+#include <optional>
 #include <type_traits>
 
 namespace Utils
@@ -187,7 +187,7 @@ auto toConstReferences(const SourceContainer &sources);
 // take
 /////////////////////////
 template<class C, typename P>
-Q_REQUIRED_RESULT optional<typename C::value_type> take(C &container, P predicate);
+Q_REQUIRED_RESULT std::optional<typename C::value_type> take(C &container, P predicate);
 template<typename C, typename R, typename S>
 Q_REQUIRED_RESULT decltype(auto) take(C &container, R S::*member);
 template<typename C, typename R, typename S>
@@ -1066,15 +1066,15 @@ auto toConstReferences(const SourceContainer &sources)
 /////////////////
 
 template<class C, typename P>
-Q_REQUIRED_RESULT optional<typename C::value_type> take(C &container, P predicate)
+Q_REQUIRED_RESULT std::optional<typename C::value_type> take(C &container, P predicate)
 {
     const auto end = std::end(container);
 
     const auto it = std::find_if(std::begin(container), end, predicate);
     if (it == end)
-        return nullopt;
+        return std::nullopt;
 
-    optional<typename C::value_type> result = Utils::make_optional(std::move(*it));
+    std::optional<typename C::value_type> result = std::make_optional(std::move(*it));
     container.erase(it);
     return result;
 }
diff --git a/src/libs/utils/archive.cpp b/src/libs/utils/archive.cpp
index b2d84a7cd7..7a3dd4b487 100644
--- a/src/libs/utils/archive.cpp
+++ b/src/libs/utils/archive.cpp
@@ -89,20 +89,20 @@ static QVector<Tool> toolsForFilePath(const FilePath &fp)
     return toolsForMimeType(mimeTypeForFile(fp));
 }
 
-static Utils::optional<Tool> resolveTool(const Tool &tool)
+static std::optional<Tool> resolveTool(const Tool &tool)
 {
     const FilePath executable =
         tool.command.executable().withExecutableSuffix().searchInPath(tool.additionalSearchDirs);
     Tool resolvedTool = tool;
     resolvedTool.command.setExecutable(executable);
-    return executable.isEmpty() ? Utils::nullopt : Utils::make_optional(resolvedTool);
+    return executable.isEmpty() ? std::nullopt : std::make_optional(resolvedTool);
 }
 
-static Utils::optional<Tool> unzipTool(const FilePath &src, const FilePath &dest)
+static std::optional<Tool> unzipTool(const FilePath &src, const FilePath &dest)
 {
     const QVector<Tool> tools = toolsForFilePath(src);
     for (const Tool &tool : tools) {
-        const Utils::optional<Tool> resolvedTool = resolveTool(tool);
+        const std::optional<Tool> resolvedTool = resolveTool(tool);
         if (resolvedTool) {
             Tool result = *resolvedTool;
             const QString srcStr = src.toString();
@@ -138,7 +138,7 @@ bool Archive::supportsFile(const FilePath &filePath, QString *reason)
 
 Archive::Archive(const FilePath &src, const FilePath &dest)
 {
-    const Utils::optional<Tool> tool = unzipTool(src, dest);
+    const std::optional<Tool> tool = unzipTool(src, dest);
     if (!tool)
         return;
     m_commandLine = tool->command;
diff --git a/src/libs/utils/aspects.cpp b/src/libs/utils/aspects.cpp
index ba1fb790ad..45d0ee0fdd 100644
--- a/src/libs/utils/aspects.cpp
+++ b/src/libs/utils/aspects.cpp
@@ -656,8 +656,8 @@ public:
 class IntegerAspectPrivate
 {
 public:
-    Utils::optional<qint64> m_minimumValue;
-    Utils::optional<qint64> m_maximumValue;
+    std::optional<qint64> m_minimumValue;
+    std::optional<qint64> m_maximumValue;
     int m_displayIntegerBase = 10;
     qint64 m_displayScaleFactor = 1;
     QString m_prefix;
@@ -670,8 +670,8 @@ public:
 class DoubleAspectPrivate
 {
 public:
-    Utils::optional<double> m_minimumValue;
-    Utils::optional<double> m_maximumValue;
+    std::optional<double> m_minimumValue;
+    std::optional<double> m_maximumValue;
     QString m_prefix;
     QString m_suffix;
     QString m_specialValueText;
@@ -784,7 +784,7 @@ void StringAspect::setValue(const QString &val)
 
     QString processedValue = val;
     if (d->m_valueAcceptor) {
-        const Utils::optional<QString> tmp = d->m_valueAcceptor(value(), val);
+        const std::optional<QString> tmp = d->m_valueAcceptor(value(), val);
         if (!tmp) {
             update(); // Make sure the original value is retained in the UI
             return;
diff --git a/src/libs/utils/aspects.h b/src/libs/utils/aspects.h
index eb6d242fd3..f46705dab1 100644
--- a/src/libs/utils/aspects.h
+++ b/src/libs/utils/aspects.h
@@ -7,11 +7,11 @@
 #include "id.h"
 #include "infolabel.h"
 #include "macroexpander.h"
-#include "optional.h"
 #include "pathchooser.h"
 
 #include <functional>
 #include <memory>
+#include <optional>
 
 QT_BEGIN_NAMESPACE
 class QAction;
@@ -337,7 +337,7 @@ public:
     void emitChangedValue() override;
 
     // Hook between UI and StringAspect:
-    using ValueAcceptor = std::function<Utils::optional<QString>(const QString &, const QString &)>;
+    using ValueAcceptor = std::function<std::optional<QString>(const QString &, const QString &)>;
     void setValueAcceptor(ValueAcceptor &&acceptor);
     QString value() const;
     void setValue(const QString &val);
diff --git a/src/libs/utils/environment.cpp b/src/libs/utils/environment.cpp
index 8131712341..d79c2dbe6c 100644
--- a/src/libs/utils/environment.cpp
+++ b/src/libs/utils/environment.cpp
@@ -406,12 +406,12 @@ const QVector<EnvironmentProvider> EnvironmentProvider::providers()
     return *environmentProviders;
 }
 
-optional<EnvironmentProvider> EnvironmentProvider::provider(const QByteArray &id)
+std::optional<EnvironmentProvider> EnvironmentProvider::provider(const QByteArray &id)
 {
     const int index = indexOf(*environmentProviders, equal(&EnvironmentProvider::id, id));
     if (index >= 0)
-        return make_optional(environmentProviders->at(index));
-    return nullopt;
+        return std::make_optional(environmentProviders->at(index));
+    return std::nullopt;
 }
 
 void EnvironmentChange::addSetValue(const QString &key, const QString &value)
diff --git a/src/libs/utils/environment.h b/src/libs/utils/environment.h
index 137719ebdd..01b4a6e9bf 100644
--- a/src/libs/utils/environment.h
+++ b/src/libs/utils/environment.h
@@ -8,9 +8,9 @@
 #include "environmentfwd.h"
 #include "filepath.h"
 #include "namevaluedictionary.h"
-#include "optional.h"
 
 #include <functional>
+#include <optional>
 
 QT_BEGIN_NAMESPACE
 class QProcessEnvironment;
@@ -150,7 +150,7 @@ public:
 
     static void addProvider(EnvironmentProvider &&provider);
     static const QVector<EnvironmentProvider> providers();
-    static optional<EnvironmentProvider> provider(const QByteArray &id);
+    static std::optional<EnvironmentProvider> provider(const QByteArray &id);
 };
 
 QTCREATOR_UTILS_EXPORT QString qtcEnvironmentVariable(const QString &key);
diff --git a/src/libs/utils/environmentdialog.cpp b/src/libs/utils/environmentdialog.cpp
index 4de3ac69b3..54350b69d0 100644
--- a/src/libs/utils/environmentdialog.cpp
+++ b/src/libs/utils/environmentdialog.cpp
@@ -7,7 +7,7 @@
 
 namespace Utils {
 
-Utils::optional<EnvironmentItems> EnvironmentDialog::getEnvironmentItems(
+std::optional<EnvironmentItems> EnvironmentDialog::getEnvironmentItems(
     QWidget *parent, const EnvironmentItems &initial, const QString &placeholderText, Polisher polisher)
 {
     return getNameValueItems(
diff --git a/src/libs/utils/environmentdialog.h b/src/libs/utils/environmentdialog.h
index e708d1d0f8..c80aa19fa3 100644
--- a/src/libs/utils/environmentdialog.h
+++ b/src/libs/utils/environmentdialog.h
@@ -15,7 +15,7 @@ class QTCREATOR_UTILS_EXPORT EnvironmentDialog : public NameValuesDialog
 {
     Q_OBJECT
 public:
-    static Utils::optional<EnvironmentItems> getEnvironmentItems(QWidget *parent = nullptr,
+    static std::optional<EnvironmentItems> getEnvironmentItems(QWidget *parent = nullptr,
                                                                  const EnvironmentItems &initial = {},
                                                                  const QString &placeholderText = {},
                                                                  Polisher polish = {});
diff --git a/src/libs/utils/fancylineedit.cpp b/src/libs/utils/fancylineedit.cpp
index 1161414aad..f1f5f4d478 100644
--- a/src/libs/utils/fancylineedit.cpp
+++ b/src/libs/utils/fancylineedit.cpp
@@ -7,7 +7,6 @@
 #include "execmenu.h"
 #include "historycompleter.h"
 #include "hostosinfo.h"
-#include "optional.h"
 #include "qtcassert.h"
 #include "utilsicons.h"
 
@@ -22,6 +21,8 @@
 #include <QValidator>
 #include <QWindow>
 
+#include <optional>
+
 /*!
     \class Utils::FancyLineEdit
 
@@ -202,7 +203,7 @@ FancyLineEdit::~FancyLineEdit()
 
 void FancyLineEdit::setTextKeepingActiveCursor(const QString &text)
 {
-    optional<int> cursor = hasFocus() ? make_optional(cursorPosition()) : nullopt;
+    std::optional<int> cursor = hasFocus() ? std::make_optional(cursorPosition()) : std::nullopt;
     setText(text);
     if (cursor)
         setCursorPosition(*cursor);
diff --git a/src/libs/utils/filepath.cpp b/src/libs/utils/filepath.cpp
index 1cb1bc1623..93eaac5235 100644
--- a/src/libs/utils/filepath.cpp
+++ b/src/libs/utils/filepath.cpp
@@ -767,7 +767,7 @@ bool isWindowsDriveLetter(QChar ch) {
 
 using RootAndPath = QPair<QStringView, QStringView>;
 
-optional<RootAndPath> windowsRootAndPath(const QStringView path)
+std::optional<RootAndPath> windowsRootAndPath(const QStringView path)
 {
     const QChar slash('/');
     QStringView workPath = path;
@@ -799,7 +799,9 @@ optional<RootAndPath> windowsRootAndPath(const QStringView path)
 
 void FilePath::setRootAndPath(QStringView path, OsType osType)
 {
-    optional<RootAndPath> windowsDriveAndPath = osType == OsType::OsTypeWindows ? windowsRootAndPath(path) : nullopt;
+    std::optional<RootAndPath> windowsDriveAndPath = osType == OsType::OsTypeWindows
+                                                         ? windowsRootAndPath(path)
+                                                         : std::nullopt;
 
     if (path.startsWith(QLatin1String("/./"))) {
         m_root = "";
diff --git a/src/libs/utils/fsengine/fileiconprovider.cpp b/src/libs/utils/fsengine/fileiconprovider.cpp
index 5076119799..b397cc9447 100644
--- a/src/libs/utils/fsengine/fileiconprovider.cpp
+++ b/src/libs/utils/fsengine/fileiconprovider.cpp
@@ -6,7 +6,6 @@
 #include <utils/fileutils.h>
 #include <utils/hostosinfo.h>
 #include <utils/mimeutils.h>
-#include <utils/optional.h>
 #include <utils/qtcassert.h>
 
 #include <QApplication>
@@ -20,6 +19,7 @@
 #include <QIcon>
 #include <QLoggingCategory>
 
+#include <optional>
 #include <variant>
 
 using namespace Utils;
@@ -49,7 +49,7 @@ using Item = std::variant<QIcon, QString>; // icon or filename for the icon
 namespace Utils {
 namespace FileIconProvider {
 
-static Utils::optional<QIcon> getIcon(QHash<QString, Item> &cache, const QString &key)
+static std::optional<QIcon> getIcon(QHash<QString, Item> &cache, const QString &key)
 {
     auto it = cache.constFind(key);
     if (it == cache.constEnd())
@@ -188,14 +188,14 @@ QIcon FileIconProviderImplementation::icon(const FilePath &filePath) const
     // Check for cached overlay icons by file suffix.
     const QString filename = !isDir ? filePath.fileName() : QString();
     if (!filename.isEmpty()) {
-        const Utils::optional<QIcon> icon = getIcon(m_filenameCache, filename);
+        const std::optional<QIcon> icon = getIcon(m_filenameCache, filename);
         if (icon)
             return *icon;
     }
 
     const QString suffix = !isDir ? filePath.suffix() : QString();
     if (!suffix.isEmpty()) {
-        const Utils::optional<QIcon> icon = getIcon(m_suffixCache, suffix);
+        const std::optional<QIcon> icon = getIcon(m_suffixCache, suffix);
         if (icon)
             return *icon;
     }
diff --git a/src/libs/utils/hostosinfo.cpp b/src/libs/utils/hostosinfo.cpp
index 1876ee1154..2b424b273c 100644
--- a/src/libs/utils/hostosinfo.cpp
+++ b/src/libs/utils/hostosinfo.cpp
@@ -94,7 +94,7 @@ bool HostOsInfo::canCreateOpenGLContext(QString *errorMessage)
 #endif
 }
 
-optional<quint64> HostOsInfo::totalMemoryInstalledInBytes()
+std::optional<quint64> HostOsInfo::totalMemoryInstalledInBytes()
 {
 #ifdef Q_OS_LINUX
     struct sysinfo info;
diff --git a/src/libs/utils/hostosinfo.h b/src/libs/utils/hostosinfo.h
index 11a07f2dbc..7626e3cacc 100644
--- a/src/libs/utils/hostosinfo.h
+++ b/src/libs/utils/hostosinfo.h
@@ -5,9 +5,10 @@
 
 #include "utils_global.h"
 
-#include "optional.h"
 #include "osspecificaspects.h"
 
+#include <optional>
+
 QT_BEGIN_NAMESPACE
 class QString;
 QT_END_NAMESPACE
@@ -83,7 +84,7 @@ public:
 
     static bool canCreateOpenGLContext(QString *errorMessage);
 
-    static optional<quint64> totalMemoryInstalledInBytes();
+    static std::optional<quint64> totalMemoryInstalledInBytes();
 
 private:
     static Qt::CaseSensitivity m_overrideFileNameCaseSensitivity;
diff --git a/src/libs/utils/layoutbuilder.h b/src/libs/utils/layoutbuilder.h
index 215dc57fcc..92912bd57a 100644
--- a/src/libs/utils/layoutbuilder.h
+++ b/src/libs/utils/layoutbuilder.h
@@ -5,12 +5,13 @@
 
 #include "utils_global.h"
 
-#include "optional.h"
 
 #include <QList>
 #include <QString>
 #include <QVariant>
 
+#include <optional>
+
 QT_BEGIN_NAMESPACE
 class QLayout;
 class QWidget;
@@ -143,7 +144,7 @@ protected:
 
     LayoutItems m_items;
     LayoutType m_layoutType;
-    Utils::optional<int> m_spacing;
+    std::optional<int> m_spacing;
 };
 
 class QTCREATOR_UTILS_EXPORT LayoutExtender : public LayoutBuilder
diff --git a/src/libs/utils/linecolumn.h b/src/libs/utils/linecolumn.h
index d326d77032..70b715b7d4 100644
--- a/src/libs/utils/linecolumn.h
+++ b/src/libs/utils/linecolumn.h
@@ -5,10 +5,10 @@
 
 #include "utils_global.h"
 
-#include "optional.h"
-
 #include <QMetaType>
 
+#include <optional>
+
 namespace Utils {
 
 class QTCREATOR_UTILS_EXPORT LineColumn
@@ -39,7 +39,7 @@ public:
     int column = -1;
 };
 
-using OptionalLineColumn = optional<LineColumn>;
+using OptionalLineColumn = std::optional<LineColumn>;
 
 } // namespace Utils
 
diff --git a/src/libs/utils/namevaluesdialog.cpp b/src/libs/utils/namevaluesdialog.cpp
index 5e6c57ac2a..195871e505 100644
--- a/src/libs/utils/namevaluesdialog.cpp
+++ b/src/libs/utils/namevaluesdialog.cpp
@@ -106,7 +106,7 @@ void NameValuesDialog::setPlaceholderText(const QString &text)
     m_editor->setPlaceholderText(text);
 }
 
-Utils::optional<NameValueItems> NameValuesDialog::getNameValueItems(QWidget *parent,
+std::optional<NameValueItems> NameValuesDialog::getNameValueItems(QWidget *parent,
                                                                     const NameValueItems &initial,
                                                                     const QString &placeholderText,
                                                                     Polisher polisher,
diff --git a/src/libs/utils/namevaluesdialog.h b/src/libs/utils/namevaluesdialog.h
index 2dc0c5a757..a0bfb253c4 100644
--- a/src/libs/utils/namevaluesdialog.h
+++ b/src/libs/utils/namevaluesdialog.h
@@ -6,12 +6,12 @@
 #include "utils_global.h"
 
 #include "namevalueitem.h"
-#include "optional.h"
 
 #include <QDialog>
 
 #include <functional>
 #include <memory>
+#include <optional>
 
 QT_BEGIN_NAMESPACE
 class QPlainTextEdit;
@@ -46,7 +46,7 @@ public:
     void setPlaceholderText(const QString &text);
 
     using Polisher = std::function<void(QWidget *)>;
-    static Utils::optional<NameValueItems> getNameValueItems(QWidget *parent = nullptr,
+    static std::optional<NameValueItems> getNameValueItems(QWidget *parent = nullptr,
                                                              const NameValueItems &initial = {},
                                                              const QString &placeholderText = {},
                                                              Polisher polish = {},
diff --git a/src/libs/utils/optional.h b/src/libs/utils/optional.h
deleted file mode 100644
index 0613ea49d5..0000000000
--- a/src/libs/utils/optional.h
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright (C) 2017 The Qt Company Ltd.
-// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
-
-#pragma once
-
-/*
-    optional<T>
-    make_optional(t)
-
-    See std(::experimental)::optional.
-*/
-
-// std::optional from Apple's Clang supports methods that throw std::bad_optional_access only
-// with deployment target >= macOS 10.14
-// TODO: Use std::optional everywhere when we can require macOS 10.14
-#if !defined(__apple_build_version__)
-
-#include <optional>
-
-namespace Utils {
-
-using std::optional;
-using std::nullopt;
-using std::nullopt_t;
-using std::in_place;
-
-// make_optional is a copy, since there is no sensible way to import functions in C++
-template<class T>
-constexpr optional<std::decay_t<T>> make_optional(T &&v)
-{
-    return optional<std::decay_t<T>>(std::forward<T>(v));
-}
-
-template<class T, class... Args>
-optional<T> make_optional(Args &&... args)
-{
-    return optional<T>(in_place, std::forward<Args>(args)...);
-}
-
-template<class T, class Up, class... Args>
-constexpr optional<T> make_optional(std::initializer_list<Up> il, Args &&... args)
-{
-    return optional<T>(in_place, il, std::forward<Args>(args)...);
-}
-
-} // namespace Utils
-
-#else
-
-#include <3rdparty/optional/optional.hpp>
-
-namespace Utils {
-
-// --> Utils::optional
-using std::experimental::optional;
-// --> Utils::nullopt
-using std::experimental::nullopt;
-using std::experimental::nullopt_t;
-// --> Utils::in_place
-using std::experimental::in_place;
-
-// TODO: make_optional is a copy, since there is no sensible way to import functions in C++
-template <class T>
-constexpr optional<typename std::decay<T>::type> make_optional(T&& v)
-{
-  return optional<typename std::decay<T>::type>(std::experimental::constexpr_forward<T>(v));
-}
-
-template <class X>
-constexpr optional<X&> make_optional(std::reference_wrapper<X> v)
-{
-  return optional<X&>(v.get());
-}
-
-} // Utils
-
-#endif
diff --git a/src/libs/utils/outputformatter.cpp b/src/libs/utils/outputformatter.cpp
index ffb749bb52..2d65f8919c 100644
--- a/src/libs/utils/outputformatter.cpp
+++ b/src/libs/utils/outputformatter.cpp
@@ -197,7 +197,7 @@ public:
     QTextCursor cursor;
     AnsiEscapeCodeHandler escapeCodeHandler;
     QPair<QString, OutputFormat> incompleteLine;
-    optional<QTextCharFormat> formatOverride;
+    std::optional<QTextCharFormat> formatOverride;
     QList<OutputLineParser *> lineParsers;
     OutputLineParser *nextParser = nullptr;
     FileInProjectFinder fileFinder;
diff --git a/src/libs/utils/outputformatter.h b/src/libs/utils/outputformatter.h
index e01371ed0b..3a31d97d26 100644
--- a/src/libs/utils/outputformatter.h
+++ b/src/libs/utils/outputformatter.h
@@ -6,12 +6,12 @@
 #include "utils_global.h"
 
 #include "filepath.h"
-#include "optional.h"
 #include "outputformat.h"
 
 #include <QObject>
 
 #include <functional>
+#include <optional>
 
 QT_BEGIN_NAMESPACE
 class QPlainTextEdit;
@@ -44,13 +44,19 @@ public:
     using LinkSpecs = QList<LinkSpec>;
     class Result {
     public:
-        Result(Status s, const LinkSpecs &l = {}, const optional<QString> &c = {},
-               const optional<OutputFormat> &f = {})
-            : status(s), linkSpecs(l), newContent(c), formatOverride(f) {}
+        Result(Status s,
+               const LinkSpecs &l = {},
+               const std::optional<QString> &c = {},
+               const std::optional<OutputFormat> &f = {})
+            : status(s)
+            , linkSpecs(l)
+            , newContent(c)
+            , formatOverride(f)
+        {}
         Status status;
         LinkSpecs linkSpecs;
-        optional<QString> newContent; // Hard content override. Only to be used in extreme cases.
-        optional<OutputFormat> formatOverride;
+        std::optional<QString> newContent; // Hard content override. Only to be used in extreme cases.
+        std::optional<OutputFormat> formatOverride;
     };
 
     static bool isLinkTarget(const QString &target);
diff --git a/src/libs/utils/pointeralgorithm.h b/src/libs/utils/pointeralgorithm.h
index ca5b797460..0a790f5b17 100644
--- a/src/libs/utils/pointeralgorithm.h
+++ b/src/libs/utils/pointeralgorithm.h
@@ -253,13 +253,13 @@ auto toRawPointer(const SourceContainer &sources)
 // take:
 /////////////////
 template<typename C>
-Q_REQUIRED_RESULT optional<ValueType<C>> take(C &container, PointerType<C> p)
+Q_REQUIRED_RESULT std::optional<ValueType<C>> take(C &container, PointerType<C> p)
 {
     return take(container, [p](const ValueType<C> &v) { return v.get() == p; });
 }
 
-template <typename C>
-Q_REQUIRED_RESULT optional<ValueType<C>> take(C &container, std::nullptr_t)
+template<typename C>
+Q_REQUIRED_RESULT std::optional<ValueType<C>> take(C &container, std::nullptr_t)
 {
     return take(container, static_cast<PointerType<C>>(nullptr));
 }
diff --git a/src/libs/utils/runextensions.h b/src/libs/utils/runextensions.h
index 131d1f24cc..ba779e131f 100644
--- a/src/libs/utils/runextensions.h
+++ b/src/libs/utils/runextensions.h
@@ -6,7 +6,6 @@
 #include "utils_global.h"
 
 #include "functiontraits.h"
-#include "optional.h"
 
 #include <QCoreApplication>
 #include <QFuture>
@@ -17,6 +16,7 @@
 #include <QThreadPool>
 
 #include <functional>
+#include <optional>
 
 // hasCallOperator & Co must be outside of any namespace
 // because of internal compiler error with MSVC2015 Update 2
@@ -38,7 +38,7 @@ struct hasCallOperator
 
 namespace Utils {
 
-using StackSizeInBytes = optional<uint>;
+using StackSizeInBytes = std::optional<uint>;
 
 namespace Internal {
 
diff --git a/src/libs/utils/settingsaccessor.cpp b/src/libs/utils/settingsaccessor.cpp
index 02aa55dfa4..ff9cb114f1 100644
--- a/src/libs/utils/settingsaccessor.cpp
+++ b/src/libs/utils/settingsaccessor.cpp
@@ -68,7 +68,7 @@ QVariantMap SettingsAccessor::restoreSettings(QWidget *parent) const
  */
 bool SettingsAccessor::saveSettings(const QVariantMap &data, QWidget *parent) const
 {
-    const optional<Issue> result = writeData(m_baseFilePath, data, parent);
+    const std::optional<Issue> result = writeData(m_baseFilePath, data, parent);
 
     const ProceedInfo pi = result ? reportIssues(result.value(), m_baseFilePath, parent) : ProceedInfo::Continue;
     return pi == ProceedInfo::Continue;
@@ -89,8 +89,9 @@ SettingsAccessor::RestoreData SettingsAccessor::readData(const FilePath &path, Q
 /*!
  * Store the \a data in \a path on disk. Do all the necessary preprocessing of the data.
  */
-optional<SettingsAccessor::Issue>
-SettingsAccessor::writeData(const FilePath &path, const QVariantMap &data, QWidget *parent) const
+std::optional<SettingsAccessor::Issue> SettingsAccessor::writeData(const FilePath &path,
+                                                                   const QVariantMap &data,
+                                                                   QWidget *parent) const
 {
     Q_UNUSED(parent)
     return writeFile(path, prepareToWriteSettings(data));
@@ -134,8 +135,8 @@ SettingsAccessor::RestoreData SettingsAccessor::readFile(const FilePath &path) c
  *
  * This method does not do *any* processing of the file contents.
  */
-optional<SettingsAccessor::Issue>
-SettingsAccessor::writeFile(const FilePath &path, const QVariantMap &data) const
+std::optional<SettingsAccessor::Issue> SettingsAccessor::writeFile(const FilePath &path,
+                                                                   const QVariantMap &data) const
 {
     if (data.isEmpty()) {
         return Issue(QCoreApplication::translate("Utils::SettingsAccessor", "Failed to Write File"),
@@ -216,11 +217,12 @@ int BackUpStrategy::compare(const SettingsAccessor::RestoreData &data1,
     return 0;
 }
 
-optional<FilePath>
-BackUpStrategy::backupName(const QVariantMap &oldData, const FilePath &path, const QVariantMap &data) const
+std::optional<FilePath> BackUpStrategy::backupName(const QVariantMap &oldData,
+                                                   const FilePath &path,
+                                                   const QVariantMap &data) const
 {
     if (oldData == data)
-        return nullopt;
+        return std::nullopt;
     return path.stringAppended(".bak");
 }
 
@@ -266,9 +268,9 @@ BackingUpSettingsAccessor::readData(const FilePath &path, QWidget *parent) const
     return result;
 }
 
-optional<SettingsAccessor::Issue>
-BackingUpSettingsAccessor::writeData(const FilePath &path, const QVariantMap &data,
-                                     QWidget *parent) const
+std::optional<SettingsAccessor::Issue> BackingUpSettingsAccessor::writeData(const FilePath &path,
+                                                                            const QVariantMap &data,
+                                                                            QWidget *parent) const
 {
     if (data.isEmpty())
         return {};
@@ -307,8 +309,11 @@ void BackingUpSettingsAccessor::backupFile(const FilePath &path, const QVariantM
         return;
 
     // Do we need to do a backup?
-    if (optional<FilePath> backupFileName = m_strategy->backupName(oldSettings.data, path, data))
+    if (std::optional<FilePath> backupFileName = m_strategy->backupName(oldSettings.data,
+                                                                        path,
+                                                                        data)) {
         path.copyFile(backupFileName.value());
+    }
 }
 
 // --------------------------------------------------------------------
@@ -337,8 +342,9 @@ int VersionedBackUpStrategy::compare(const SettingsAccessor::RestoreData &data1,
     return -1;
 }
 
-optional<FilePath>
-VersionedBackUpStrategy::backupName(const QVariantMap &oldData, const FilePath &path, const QVariantMap &data) const
+std::optional<FilePath> VersionedBackUpStrategy::backupName(const QVariantMap &oldData,
+                                                            const FilePath &path,
+                                                            const QVariantMap &data) const
 {
     Q_UNUSED(data)
     FilePath backupName = path;
@@ -356,7 +362,7 @@ VersionedBackUpStrategy::backupName(const QVariantMap &oldData, const FilePath &
             backupName = backupName.stringAppended('.' + QString::number(oldVersion));
     }
     if (backupName == path)
-        return nullopt;
+        return std::nullopt;
     return backupName;
 }
 
@@ -590,7 +596,7 @@ SettingsAccessor::RestoreData MergingSettingsAccessor::readData(const FilePath &
     if (mainData.hasIssue()) {
         if (reportIssues(mainData.issue.value(), mainData.path, parent) == DiscardAndContinue)
             mainData.data.clear();
-        mainData.issue = nullopt;
+        mainData.issue = std::nullopt;
     }
 
     RestoreData secondaryData
@@ -628,7 +634,7 @@ SettingsAccessor::RestoreData MergingSettingsAccessor::readData(const FilePath &
     if (secondaryData.hasIssue()) {
         if (reportIssues(secondaryData.issue.value(), secondaryData.path, parent) == DiscardAndContinue)
             secondaryData.data.clear();
-        secondaryData.issue = nullopt;
+        secondaryData.issue = std::nullopt;
     }
 
     if (!secondaryData.data.isEmpty())
@@ -736,7 +742,7 @@ static QVariant mergeQVariantMapsRecursion(const QVariantMap &mainTree, const QV
         global.key = keyPrefix + key;
         local.key = key;
 
-        optional<QPair<QString, QVariant>> mergeResult = merge(global, local);
+        std::optional<QPair<QString, QVariant>> mergeResult = merge(global, local);
         if (!mergeResult)
             continue;
 
diff --git a/src/libs/utils/settingsaccessor.h b/src/libs/utils/settingsaccessor.h
index 07c06992cd..bf8b15ce94 100644
--- a/src/libs/utils/settingsaccessor.h
+++ b/src/libs/utils/settingsaccessor.h
@@ -6,13 +6,13 @@
 #include "utils_global.h"
 
 #include "filepath.h"
-#include "optional.h"
 
 #include <QHash>
 #include <QMessageBox>
 #include <QVariantMap>
 
 #include <memory>
+#include <optional>
 
 namespace Utils {
 
@@ -41,7 +41,7 @@ QTCREATOR_UTILS_EXPORT void setOriginalVersionInMap(QVariantMap &data, int versi
 QTCREATOR_UTILS_EXPORT void setSettingsIdInMap(QVariantMap &data, const QByteArray &id);
 
 class PersistentSettingsWriter;
-using SettingsMergeResult = optional<QPair<QString, QVariant>>;
+using SettingsMergeResult = std::optional<QPair<QString, QVariant>>;
 
 // --------------------------------------------------------------------
 // SettingsAccessor:
@@ -89,7 +89,7 @@ public:
 
         FilePath path;
         QVariantMap data;
-        optional<Issue> issue;
+        std::optional<Issue> issue;
     };
 
     QVariantMap restoreSettings(QWidget *parent) const;
@@ -104,7 +104,9 @@ public:
     FilePath baseFilePath() const { return m_baseFilePath; }
 
     virtual RestoreData readData(const FilePath &path, QWidget *parent) const;
-    virtual optional<Issue> writeData(const FilePath &path, const QVariantMap &data, QWidget *parent) const;
+    virtual std::optional<Issue> writeData(const FilePath &path,
+                                           const QVariantMap &data,
+                                           QWidget *parent) const;
 
 protected:
     // Report errors:
@@ -115,7 +117,7 @@ protected:
     virtual QVariantMap prepareToWriteSettings(const QVariantMap &data) const;
 
     virtual RestoreData readFile(const FilePath &path) const;
-    virtual optional<Issue> writeFile(const FilePath &path, const QVariantMap &data) const;
+    virtual std::optional<Issue> writeFile(const FilePath &path, const QVariantMap &data) const;
 
 private:
     FilePath m_baseFilePath;
@@ -138,8 +140,9 @@ public:
     virtual int compare(const SettingsAccessor::RestoreData &data1,
                         const SettingsAccessor::RestoreData &data2) const;
 
-    virtual optional<FilePath>
-    backupName(const QVariantMap &oldData, const FilePath &path, const QVariantMap &data) const;
+    virtual std::optional<FilePath> backupName(const QVariantMap &oldData,
+                                               const FilePath &path,
+                                               const QVariantMap &data) const;
 };
 
 class QTCREATOR_UTILS_EXPORT BackingUpSettingsAccessor : public SettingsAccessor
@@ -151,8 +154,9 @@ public:
                               const QString &displayName, const QString &applicationDisplayName);
 
     RestoreData readData(const FilePath &path, QWidget *parent) const override;
-    optional<Issue> writeData(const FilePath &path, const QVariantMap &data,
-                              QWidget *parent) const override;
+    std::optional<Issue> writeData(const FilePath &path,
+                                   const QVariantMap &data,
+                                   QWidget *parent) const override;
 
     BackUpStrategy *strategy() const { return m_strategy.get(); }
 
@@ -180,8 +184,9 @@ public:
     int compare(const SettingsAccessor::RestoreData &data1,
                 const SettingsAccessor::RestoreData &data2) const override;
 
-    optional<FilePath>
-    backupName(const QVariantMap &oldData, const FilePath &path, const QVariantMap &data) const override;
+    std::optional<FilePath> backupName(const QVariantMap &oldData,
+                                       const FilePath &path,
+                                       const QVariantMap &data) const override;
 
     const UpgradingSettingsAccessor *accessor() const { return m_accessor; }
 
diff --git a/src/libs/utils/utils.qbs b/src/libs/utils/utils.qbs
index 8da82286b1..983facc11e 100644
--- a/src/libs/utils/utils.qbs
+++ b/src/libs/utils/utils.qbs
@@ -202,8 +202,6 @@ Project {
             "navigationtreeview.h",
             "networkaccessmanager.cpp",
             "networkaccessmanager.h",
-            "optional.h",
-            "../3rdparty/optional/optional.hpp",
             "osspecificaspects.h",
             "outputformat.h",
             "outputformatter.cpp",
diff --git a/src/plugins/android/avdmanageroutputparser.cpp b/src/plugins/android/avdmanageroutputparser.cpp
index 7da4c3cdd8..dbe6d9faa0 100644
--- a/src/plugins/android/avdmanageroutputparser.cpp
+++ b/src/plugins/android/avdmanageroutputparser.cpp
@@ -6,13 +6,13 @@
 #include <projectexplorer/projectexplorerconstants.h>
 #include <utils/algorithm.h>
 #include <utils/fileutils.h>
-#include <utils/optional.h>
 #include <utils/qtcassert.h>
 
 #include <QLoggingCategory>
 #include <QRegularExpression>
 #include <QSettings>
 
+#include <optional>
 #include <variant>
 
 namespace {
@@ -44,7 +44,7 @@ static bool valueForKey(QString key, const QString &line, QString *value = nullp
     return false;
 }
 
-static Utils::optional<AndroidDeviceInfo> parseAvd(const QStringList &deviceInfo)
+static std::optional<AndroidDeviceInfo> parseAvd(const QStringList &deviceInfo)
 {
     AndroidDeviceInfo avd;
     for (const QString &line : deviceInfo) {
@@ -100,7 +100,7 @@ AndroidDeviceInfoList parseAvdList(const QString &output, QStringList *avdErrorP
                 if (valueForKey(avdInfoPathKey, line, &value))
                     return AvdResult(value); // error path
             }
-        } else if (Utils::optional<AndroidDeviceInfo> avd = parseAvd(avdInfo)) {
+        } else if (std::optional<AndroidDeviceInfo> avd = parseAvd(avdInfo)) {
             // armeabi-v7a devices can also run armeabi code
             if (avd->cpuAbi.contains(Constants::ANDROID_ABI_ARMEABI_V7A))
                 avd->cpuAbi << Constants::ANDROID_ABI_ARMEABI;
diff --git a/src/plugins/autotest/itemdatacache.h b/src/plugins/autotest/itemdatacache.h
index 47ee2fb617..f01a2e9316 100644
--- a/src/plugins/autotest/itemdatacache.h
+++ b/src/plugins/autotest/itemdatacache.h
@@ -6,11 +6,11 @@
 #include "itestframework.h"
 #include "testtreeitem.h"
 
-#include <utils/optional.h>
-
 #include <QRegularExpression>
 #include <QVariantHash>
 
+#include <optional>
+
 namespace Autotest {
 namespace Internal {
 
@@ -35,13 +35,13 @@ public:
         }
     }
 
-    Utils::optional<T> get(ITestTreeItem *item)
+    std::optional<T> get(ITestTreeItem *item)
     {
         auto entry = m_cache.find(item->cacheName());
         if (entry == m_cache.end())
-            return Utils::nullopt;
+            return std::nullopt;
         entry->generation = 0;
-        return Utils::make_optional(entry->value);
+        return std::make_optional(entry->value);
     };
 
     void clear() { m_cache.clear(); }
diff --git a/src/plugins/autotest/qtest/qttestparser.cpp b/src/plugins/autotest/qtest/qttestparser.cpp
index 9d09960b6a..492e584359 100644
--- a/src/plugins/autotest/qtest/qttestparser.cpp
+++ b/src/plugins/autotest/qtest/qttestparser.cpp
@@ -314,7 +314,7 @@ bool QtTestParser::processDocument(QFutureInterface<TestParseResultPtr> &futureI
     for (const TestCase &testCase : testCaseList) {
         if (!testCase.name.isEmpty()) {
             TestCaseData data;
-            Utils::optional<bool> earlyReturn = fillTestCaseData(testCase.name, doc, data);
+            std::optional<bool> earlyReturn = fillTestCaseData(testCase.name, doc, data);
             if (earlyReturn.has_value() || !data.valid)
                 continue;
 
@@ -333,7 +333,7 @@ bool QtTestParser::processDocument(QFutureInterface<TestParseResultPtr> &futureI
     return reported;
 }
 
-Utils::optional<bool> QtTestParser::fillTestCaseData(
+std::optional<bool> QtTestParser::fillTestCaseData(
         const QString &testCaseName, const CPlusPlus::Document::Ptr &doc,
         TestCaseData &data) const
 {
@@ -366,7 +366,7 @@ Utils::optional<bool> QtTestParser::fillTestCaseData(
 
     data.fileName = Utils::FilePath::fromString(declaringDoc->fileName());
     data.valid = true;
-    return Utils::optional<bool>();
+    return std::optional<bool>();
 }
 
 QtTestParseResult *QtTestParser::createParseResult(
diff --git a/src/plugins/autotest/qtest/qttestparser.h b/src/plugins/autotest/qtest/qttestparser.h
index ba6f8856a8..c64e2e159f 100644
--- a/src/plugins/autotest/qtest/qttestparser.h
+++ b/src/plugins/autotest/qtest/qttestparser.h
@@ -8,7 +8,7 @@
 #include "qttest_utils.h"
 #include "qttesttreeitem.h"
 
-#include <utils/optional.h>
+#include <optional>
 
 namespace CppEditor { class CppModelManager; }
 
@@ -53,7 +53,7 @@ private:
         bool valid = false;
     };
 
-    Utils::optional<bool> fillTestCaseData(const QString &testCaseName,
+    std::optional<bool> fillTestCaseData(const QString &testCaseName,
                                            const CPlusPlus::Document::Ptr &doc,
                                            TestCaseData &data) const;
     QtTestParseResult *createParseResult(const QString &testCaseName, const TestCaseData &data,
diff --git a/src/plugins/autotest/testnavigationwidget.cpp b/src/plugins/autotest/testnavigationwidget.cpp
index 48720a06c8..c6cb1ae4ee 100644
--- a/src/plugins/autotest/testnavigationwidget.cpp
+++ b/src/plugins/autotest/testnavigationwidget.cpp
@@ -318,7 +318,8 @@ void TestNavigationWidget::reapplyCachedExpandedState()
     using namespace Utils;
     for (TreeItem *rootNode : *m_model->rootItem()) {
         rootNode->forAllChildren([this](TreeItem *child) {
-            optional<bool> cached = m_expandedStateCache.get(static_cast<ITestTreeItem *>(child));
+            std::optional<bool> cached = m_expandedStateCache.get(
+                static_cast<ITestTreeItem *>(child));
             if (cached.has_value()) {
                 QModelIndex index = child->index();
                 if (m_view->isExpanded(index) != cached.value())
diff --git a/src/plugins/autotest/testresultmodel.cpp b/src/plugins/autotest/testresultmodel.cpp
index 66b69bc2c0..b76a5b3f03 100644
--- a/src/plugins/autotest/testresultmodel.cpp
+++ b/src/plugins/autotest/testresultmodel.cpp
@@ -58,7 +58,7 @@ static QIcon testResultIcon(ResultType result) {
     return icons[int(result)];
 }
 
-static QIcon testSummaryIcon(const Utils::optional<TestResultItem::SummaryEvaluation> &summary)
+static QIcon testSummaryIcon(const std::optional<TestResultItem::SummaryEvaluation> &summary)
 {
     if (!summary)
         return QIcon();
@@ -114,7 +114,7 @@ static bool isSignificant(ResultType type)
 }
 
 void TestResultItem::updateResult(bool &changed, ResultType addedChildType,
-                                  const Utils::optional<SummaryEvaluation> &summary)
+                                  const std::optional<SummaryEvaluation> &summary)
 {
     changed = false;
     if (m_testResult->result() != ResultType::TestStart)
diff --git a/src/plugins/autotest/testresultmodel.h b/src/plugins/autotest/testresultmodel.h
index 7ea51a1a26..3749abe101 100644
--- a/src/plugins/autotest/testresultmodel.h
+++ b/src/plugins/autotest/testresultmodel.h
@@ -10,9 +10,10 @@
 #include <QSet>
 #include <QSortFilterProxyModel>
 
-#include <utils/optional.h>
 #include <utils/treemodel.h>
 
+#include <optional>
+
 namespace Autotest {
 namespace Internal {
 
@@ -36,16 +37,16 @@ public:
     };
 
     void updateResult(bool &changed, ResultType addedChildType,
-                      const Utils::optional<SummaryEvaluation> &summary);
+                      const std::optional<SummaryEvaluation> &summary);
 
     TestResultItem *intermediateFor(const TestResultItem *item) const;
     TestResultItem *createAndAddIntermediateFor(const TestResultItem *child);
     QString resultString() const;
-    Utils::optional<SummaryEvaluation> summaryResult() const { return m_summaryResult; }
+    std::optional<SummaryEvaluation> summaryResult() const { return m_summaryResult; }
 
 private:
     TestResultPtr m_testResult;
-    Utils::optional<SummaryEvaluation> m_summaryResult;
+    std::optional<SummaryEvaluation> m_summaryResult;
 };
 
 class TestResultModel : public Utils::TreeModel<TestResultItem>
diff --git a/src/plugins/autotest/testtreemodel.cpp b/src/plugins/autotest/testtreemodel.cpp
index c1db6af365..d50d801858 100644
--- a/src/plugins/autotest/testtreemodel.cpp
+++ b/src/plugins/autotest/testtreemodel.cpp
@@ -259,7 +259,7 @@ void TestTreeModel::onBuildSystemTestsUpdated()
     for (const auto &tci : bs->testcasesInfo()) {
         ITestTreeItem *item = testTool->createItemFromTestCaseInfo(tci);
         QTC_ASSERT(item, continue);
-        if (Utils::optional<Qt::CheckState> cached = m_checkStateCache->get(item))
+        if (std::optional<Qt::CheckState> cached = m_checkStateCache->get(item))
             item->setData(0, cached.value(), Qt::CheckStateRole);
         m_checkStateCache->insert(item, item->checked());
         rootNode->appendChild(item);
@@ -393,7 +393,7 @@ void TestTreeModel::synchronizeTestTools()
                 for (const auto &tci : bs->testcasesInfo()) {
                     ITestTreeItem *item = testTool->createItemFromTestCaseInfo(tci);
                     QTC_ASSERT(item, continue);
-                    if (Utils::optional<Qt::CheckState> cached = m_checkStateCache->get(item))
+                    if (std::optional<Qt::CheckState> cached = m_checkStateCache->get(item))
                         item->setData(0, cached.value(), Qt::CheckStateRole);
                     m_checkStateCache->insert(item, item->checked());
                     rootNode->appendChild(item);
@@ -592,13 +592,13 @@ void TestTreeModel::insertItemInParent(TestTreeItem *item, TestTreeItem *root, b
         delete item;
     } else {
         // restore former check state if available
-        Utils::optional<Qt::CheckState> cached = m_checkStateCache->get(item);
+        std::optional<Qt::CheckState> cached = m_checkStateCache->get(item);
         if (cached.has_value())
             item->setData(0, cached.value(), Qt::CheckStateRole);
         else
             applyParentCheckState(parentNode, item);
         // ..and the failed state if available
-        Utils::optional<bool> failed = m_failedStateCache.get(item);
+        std::optional<bool> failed = m_failedStateCache.get(item);
         if (failed.has_value())
             item->setData(0, *failed, FailedRole);
         parentNode->appendChild(item);
@@ -717,10 +717,10 @@ void TestTreeModel::handleParseResult(const TestParseResult *result, TestTreeIte
     newItem->forAllChildItems([this](TestTreeItem *childItem) {
         if (!m_checkStateCache) // parse results may arrive after session switch / project close
             return;
-        Utils::optional<Qt::CheckState> cached = m_checkStateCache->get(childItem);
+        std::optional<Qt::CheckState> cached = m_checkStateCache->get(childItem);
         if (cached.has_value())
             childItem->setData(0, cached.value(), Qt::CheckStateRole);
-        Utils::optional<bool> failed = m_failedStateCache.get(childItem);
+        std::optional<bool> failed = m_failedStateCache.get(childItem);
         if (failed.has_value())
             childItem->setData(0, *failed, FailedRole);
     });
diff --git a/src/plugins/bineditor/bineditorwidget.cpp b/src/plugins/bineditor/bineditorwidget.cpp
index 79f38cf67d..a6f77425ca 100644
--- a/src/plugins/bineditor/bineditorwidget.cpp
+++ b/src/plugins/bineditor/bineditorwidget.cpp
@@ -536,12 +536,12 @@ QChar BinEditorWidget::displayChar(char ch) const
     return uc.at(0);
 }
 
-Utils::optional<qint64> BinEditorWidget::posAt(const QPoint &pos, bool includeEmptyArea) const
+std::optional<qint64> BinEditorWidget::posAt(const QPoint &pos, bool includeEmptyArea) const
 {
     const int xoffset = horizontalScrollBar()->value();
     int x = xoffset + pos.x() - m_margin - m_labelWidth;
     if (!includeEmptyArea && x < 0)
-        return Utils::nullopt;
+        return std::nullopt;
     int column = qMin(15, qMax(0,x) / m_columnWidth);
     const qint64 topLine = verticalScrollBar()->value();
     const qint64 line = topLine + pos.y() / m_lineHeight;
@@ -559,12 +559,12 @@ Utils::optional<qint64> BinEditorWidget::posAt(const QPoint &pos, bool includeEm
                 break;
         }
         if (!includeEmptyArea && x > 0) // right of the text area
-            return Utils::nullopt;
+            return std::nullopt;
     }
 
     const qint64 bytePos = line * m_bytesPerLine + column;
     if (!includeEmptyArea && bytePos >= m_size)
-        return Utils::nullopt;
+        return std::nullopt;
     return qMin(m_size - 1, bytePos);
 }
 
@@ -1163,7 +1163,7 @@ QString BinEditorWidget::toolTip(const QHelpEvent *helpEvent) const
     } while (startInLine <= selEnd);
     if (!insideSelection) {
         // show popup for byte under cursor
-        Utils::optional<qint64> pos = posAt(helpEvent->pos(), /*includeEmptyArea*/false);
+        std::optional<qint64> pos = posAt(helpEvent->pos(), /*includeEmptyArea*/false);
         if (!pos)
             return QString();
         selStart = pos.value();
diff --git a/src/plugins/bineditor/bineditorwidget.h b/src/plugins/bineditor/bineditorwidget.h
index ffafcbd32e..596f98b3c3 100644
--- a/src/plugins/bineditor/bineditorwidget.h
+++ b/src/plugins/bineditor/bineditorwidget.h
@@ -8,7 +8,6 @@
 #include "bineditorservice.h"
 
 #include <utils/filepath.h>
-#include <utils/optional.h>
 
 #include <QAbstractScrollArea>
 #include <QBasicTimer>
@@ -19,6 +18,8 @@
 #include <QTextDocument>
 #include <QTextFormat>
 
+#include <optional>
+
 QT_BEGIN_NAMESPACE
 class QHelpEvent;
 class QMenu;
@@ -194,7 +195,7 @@ private:
     QBasicTimer m_cursorBlinkTimer;
 
     void init();
-    Utils::optional<qint64> posAt(const QPoint &pos, bool includeEmptyArea = true) const;
+    std::optional<qint64> posAt(const QPoint &pos, bool includeEmptyArea = true) const;
     bool inTextArea(const QPoint &pos) const;
     QRect cursorRect() const;
     void updateLines();
diff --git a/src/plugins/clangcodemodel/clangdast.cpp b/src/plugins/clangcodemodel/clangdast.cpp
index da2d68ae24..4e1ce3f780 100644
--- a/src/plugins/clangcodemodel/clangdast.cpp
+++ b/src/plugins/clangcodemodel/clangdast.cpp
@@ -23,20 +23,26 @@ static constexpr char16_t arcanaKey[] = u"arcana";
 
 QString ClangdAstNode::role() const { return typedValue<QString>(roleKey); }
 QString ClangdAstNode::kind() const { return typedValue<QString>(kindKey); }
-optional<QString> ClangdAstNode::detail() const { return optionalValue<QString>(detailKey); }
-optional<QString> ClangdAstNode::arcana() const { return optionalValue<QString>(arcanaKey); }
+std::optional<QString> ClangdAstNode::detail() const
+{
+    return optionalValue<QString>(detailKey);
+}
+std::optional<QString> ClangdAstNode::arcana() const
+{
+    return optionalValue<QString>(arcanaKey);
+}
 Range ClangdAstNode::range() const { return typedValue<Range>(rangeKey); }
 bool ClangdAstNode::hasRange() const { return contains(rangeKey); }
 bool ClangdAstNode::isValid() const { return contains(roleKey) && contains(kindKey); }
 
-optional<QList<ClangdAstNode> > ClangdAstNode::children() const
+std::optional<QList<ClangdAstNode>> ClangdAstNode::children() const
 {
     return optionalArray<ClangdAstNode>(childrenKey);
 }
 
 bool ClangdAstNode::arcanaContains(const QString &s) const
 {
-    const optional<QString> arcanaString = arcana();
+    const std::optional<QString> arcanaString = arcana();
     return arcanaString && arcanaString->contains(s);
 }
 
@@ -88,7 +94,7 @@ bool ClangdAstNode::isTemplateParameterDeclaration() const
 
 QString ClangCodeModel::Internal::ClangdAstNode::type() const
 {
-    const optional<QString> arcanaString = arcana();
+    const std::optional<QString> arcanaString = arcana();
     if (!arcanaString)
         return {};
     return typeFromPos(*arcanaString, 0);
@@ -156,7 +162,7 @@ bool ClangdAstNode::hasConstType() const
 
 bool ClangdAstNode::childContainsRange(int index, const LanguageServerProtocol::Range &range) const
 {
-    const optional<QList<ClangdAstNode>> childList = children();
+    const std::optional<QList<ClangdAstNode>> childList = children();
     return childList && childList->size() > index && childList->at(index).range().contains(range);
 }
 
@@ -171,7 +177,7 @@ QString ClangdAstNode::operatorString() const
     if (kind() == "BinaryOperator")
         return detail().value_or(QString());
     QTC_ASSERT(kind() == "CXXOperatorCall", return {});
-    const optional<QString> arcanaString = arcana();
+    const std::optional<QString> arcanaString = arcana();
     if (!arcanaString)
         return {};
     const int closingQuoteOffset = arcanaString->lastIndexOf('\'');
@@ -186,7 +192,7 @@ QString ClangdAstNode::operatorString() const
 
 ClangdAstNode::FileStatus ClangdAstNode::fileStatus(const FilePath &thisFile) const
 {
-    const optional<QString> arcanaString = arcana();
+    const std::optional<QString> arcanaString = arcana();
     if (!arcanaString)
         return FileStatus::Unknown;
 
@@ -368,7 +374,7 @@ MessageId requestAst(Client *client, const FilePath &filePath, const Range range
 
         // The region of the source code whose AST is fetched. The highest-level node that entirely
         // contains the range is returned.
-        optional<Range> range() const { return optionalValue<Range>(rangeKey); }
+        std::optional<Range> range() const { return optionalValue<Range>(rangeKey); }
         void setRange(const Range &range) { insert(rangeKey, range); }
 
         bool isValid() const override { return contains(textDocumentKey); }
diff --git a/src/plugins/clangcodemodel/clangdast.h b/src/plugins/clangcodemodel/clangdast.h
index 9709de1fd4..7419d4f89e 100644
--- a/src/plugins/clangcodemodel/clangdast.h
+++ b/src/plugins/clangcodemodel/clangdast.h
@@ -40,11 +40,11 @@ public:
     QString kind() const;
 
     // Brief additional details, such as ‘||’. Information present here depends on the node kind.
-    Utils::optional<QString> detail() const;
+    std::optional<QString> detail() const;
 
     // One line dump of information, similar to that printed by clang -Xclang -ast-dump.
     // Only available for certain types of nodes.
-    Utils::optional<QString> arcana() const;
+    std::optional<QString> arcana() const;
 
     // The part of the code that produced this node. Missing for implicit nodes, nodes produced
     // by macro expansion, etc.
@@ -52,7 +52,7 @@ public:
 
     // Descendants describing the internal structure. The tree of nodes is similar to that printed
     // by clang -Xclang -ast-dump, or that traversed by clang::RecursiveASTVisitor.
-    Utils::optional<QList<ClangdAstNode>> children() const;
+    std::optional<QList<ClangdAstNode>> children() const;
 
     bool hasRange() const;
     bool arcanaContains(const QString &s) const;
diff --git a/src/plugins/clangcodemodel/clangdclient.cpp b/src/plugins/clangcodemodel/clangdclient.cpp
index 34de081eb3..e7e34251f5 100644
--- a/src/plugins/clangcodemodel/clangdclient.cpp
+++ b/src/plugins/clangcodemodel/clangdclient.cpp
@@ -99,7 +99,7 @@ public:
     QString usr() const { return typedValue<QString>(usrKey); }
 
     // the clangd-specific opaque symbol ID
-    Utils::optional<QString> id() const { return optionalValue<QString>(idKey); }
+    std::optional<QString> id() const { return optionalValue<QString>(idKey); }
 
     bool isValid() const override
     {
@@ -206,7 +206,7 @@ public:
         m_data.emplace(std::make_pair(doc, VersionedDocData(doc, data)));
     }
     void remove(const DocType &doc) { m_data.erase(doc); }
-    Utils::optional<VersionedDocData<DocType, DataType>> take(const DocType &doc)
+    std::optional<VersionedDocData<DocType, DataType>> take(const DocType &doc)
     {
         const auto it = m_data.find(doc);
         if (it == m_data.end())
@@ -215,7 +215,7 @@ public:
         m_data.erase(it);
         return data;
     }
-    Utils::optional<DataType> get(const DocType &doc)
+    std::optional<DataType> get(const DocType &doc)
     {
         const auto it = m_data.find(doc);
         if (it == m_data.end())
@@ -251,7 +251,7 @@ public:
         : q(q), settings(CppEditor::ClangdProjectSettings(project).settings()) {}
 
     void findUsages(TextDocument *document, const QTextCursor &cursor,
-                    const QString &searchTerm, const Utils::optional<QString> &replacement,
+                    const QString &searchTerm, const std::optional<QString> &replacement,
                     bool categorize);
 
     void handleDeclDefSwitchReplies();
@@ -275,7 +275,7 @@ public:
     ClangdFollowSymbol *followSymbol = nullptr;
     ClangdSwitchDeclDef *switchDeclDef = nullptr;
     ClangdFindLocalReferences *findLocalRefs = nullptr;
-    Utils::optional<QVersionNumber> versionNumber;
+    std::optional<QVersionNumber> versionNumber;
 
     QHash<TextDocument *, HighlightingData> highlightingData;
     QHash<Utils::FilePath, CppEditor::BaseEditorDocumentParser::Configuration> parserConfigs;
@@ -354,7 +354,7 @@ ClangdClient::ClangdClient(Project *project, const Utils::FilePath &jsonDbDir)
     for (const Client *client : clients)
         qCWarning(clangdLog) << client->name() << client->stateString();
     ClientCapabilities caps = Client::defaultClientCapabilities();
-    Utils::optional<TextDocumentClientCapabilities> textCaps = caps.textDocument();
+    std::optional<TextDocumentClientCapabilities> textCaps = caps.textDocument();
     if (textCaps) {
         ClangdTextDocumentClientCapabilities clangdTextCaps(*textCaps);
         clangdTextCaps.clearDocumentHighlight();
@@ -362,7 +362,7 @@ ClangdClient::ClangdClient(Project *project, const Utils::FilePath &jsonDbDir)
         diagnostics.enableCategorySupport();
         diagnostics.enableCodeActionsInline();
         clangdTextCaps.setPublishDiagnostics(diagnostics);
-        Utils::optional<TextDocumentClientCapabilities::CompletionCapabilities> completionCaps
+        std::optional<TextDocumentClientCapabilities::CompletionCapabilities> completionCaps
                 = textCaps->completion();
         if (completionCaps)
             clangdTextCaps.setCompletion(ClangdCompletionCapabilities(*completionCaps));
@@ -441,7 +441,7 @@ void ClangdClient::closeExtraFile(const Utils::FilePath &filePath)
 }
 
 void ClangdClient::findUsages(TextDocument *document, const QTextCursor &cursor,
-                              const Utils::optional<QString> &replacement)
+                              const std::optional<QString> &replacement)
 {
     // Quick check: Are we even on anything searchable?
     const QTextCursor adjustedCursor = d->adjustedCursor(cursor, document);
@@ -615,7 +615,7 @@ CppEditor::ClangdSettings::Data ClangdClient::settingsData() const { return d->s
 
 void ClangdClient::Private::findUsages(TextDocument *document,
         const QTextCursor &cursor, const QString &searchTerm,
-        const Utils::optional<QString> &replacement, bool categorize)
+        const std::optional<QString> &replacement, bool categorize)
 {
     const auto findRefs = new ClangdFindReferences(q, document, cursor, searchTerm, replacement,
                                                    categorize);
@@ -753,7 +753,7 @@ void ClangdClient::clearTasks(const Utils::FilePath &filePath)
     d->issuePaneEntries[filePath].clear();
 }
 
-Utils::optional<bool> ClangdClient::hasVirtualFunctionAt(TextDocument *doc, int revision,
+std::optional<bool> ClangdClient::hasVirtualFunctionAt(TextDocument *doc, int revision,
                                                          const Range &range)
 {
     const auto highlightingData = d->highlightingData.constFind(doc);
@@ -860,7 +860,7 @@ void ClangdClient::switchHeaderSource(const Utils::FilePath &filePath, bool inNe
     };
     SwitchSourceHeaderRequest req(filePath);
     req.setResponseCallback([inNextSplit](const SwitchSourceHeaderRequest::Response &response) {
-        if (const Utils::optional<QJsonValue> result = response.result()) {
+        if (const std::optional<QJsonValue> result = response.result()) {
             const DocumentUri uri = DocumentUri::fromProtocol(result->toString());
             const Utils::FilePath filePath = uri.toFilePath();
             if (!filePath.isEmpty())
@@ -900,7 +900,7 @@ void ClangdClient::findLocalUsages(TextDocument *document, const QTextCursor &cu
 void ClangdClient::gatherHelpItemForTooltip(const HoverRequest::Response &hoverResponse,
                                             const DocumentUri &uri)
 {
-    if (const Utils::optional<HoverResult> result = hoverResponse.result()) {
+    if (const std::optional<HoverResult> result = hoverResponse.result()) {
         if (auto hover = std::get_if<Hover>(&(*result))) {
             const HoverContent content = hover->content();
             const MarkupContent *const markup = std::get_if<MarkupContent>(&content);
@@ -942,7 +942,7 @@ void ClangdClient::gatherHelpItemForTooltip(const HoverRequest::Response &hoverR
     const auto astHandler = [this, uri, hoverResponse](const ClangdAstNode &ast, const MessageId &) {
         const MessageId id = hoverResponse.id();
         Range range;
-        if (const Utils::optional<HoverResult> result = hoverResponse.result()) {
+        if (const std::optional<HoverResult> result = hoverResponse.result()) {
             if (auto hover = std::get_if<Hover>(&(*result)))
                 range = hover->range().value_or(Range());
         }
@@ -953,12 +953,12 @@ void ClangdClient::gatherHelpItemForTooltip(const HoverRequest::Response &hoverR
         }
         ClangdAstNode node = path.last();
         if (node.role() == "expression" && node.kind() == "ImplicitCast") {
-            const Utils::optional<QList<ClangdAstNode>> children = node.children();
+            const std::optional<QList<ClangdAstNode>> children = node.children();
             if (children && !children->isEmpty())
                 node = children->first();
         }
         while (node.kind() == "Qualified") {
-            const Utils::optional<QList<ClangdAstNode>> children = node.children();
+            const std::optional<QList<ClangdAstNode>> children = node.children();
             if (children && !children->isEmpty())
                 node = children->first();
         }
@@ -1120,7 +1120,7 @@ QTextCursor ClangdClient::Private::adjustedCursor(const QTextCursor &cursor,
             case T_DOT:
                 break;
             case T_ARROW: {
-                const Utils::optional<ClangdAstNode> clangdAst = astCache.get(doc);
+                const std::optional<ClangdAstNode> clangdAst = astCache.get(doc);
                 if (!clangdAst)
                     return cursor;
                 const ClangdAstPath clangdAstPath = getAstPath(*clangdAst, Range(cursor));
@@ -1289,7 +1289,7 @@ void ClangdClient::Private::handleSemanticTokens(TextDocument *doc,
     getAndHandleAst(doc, astHandler, AstCallbackMode::SyncIfPossible);
 }
 
-Utils::optional<QList<CodeAction> > ClangdDiagnostic::codeActions() const
+std::optional<QList<CodeAction> > ClangdDiagnostic::codeActions() const
 {
     auto actions = optionalArray<LanguageServerProtocol::CodeAction>(u"codeActions");
     if (!actions)
diff --git a/src/plugins/clangcodemodel/clangdclient.h b/src/plugins/clangcodemodel/clangdclient.h
index 5b6c22bf1a..fe18af4087 100644
--- a/src/plugins/clangcodemodel/clangdclient.h
+++ b/src/plugins/clangcodemodel/clangdclient.h
@@ -9,10 +9,11 @@
 #include <cppeditor/cursorineditor.h>
 #include <languageclient/client.h>
 #include <utils/link.h>
-#include <utils/optional.h>
 
 #include <QVersionNumber>
 
+#include <optional>
+
 namespace CppEditor { class CppEditorWidget; }
 namespace LanguageServerProtocol { class Range; }
 namespace ProjectExplorer {
@@ -48,7 +49,7 @@ public:
     void closeExtraFile(const Utils::FilePath &filePath);
 
     void findUsages(TextEditor::TextDocument *document, const QTextCursor &cursor,
-                    const Utils::optional<QString> &replacement);
+                    const std::optional<QString> &replacement);
     void followSymbol(TextEditor::TextDocument *document,
             const QTextCursor &cursor,
             CppEditor::CppEditorWidget *editorWidget,
@@ -85,7 +86,7 @@ public:
     void switchIssuePaneEntries(const Utils::FilePath &filePath);
     void addTask(const ProjectExplorer::Task &task);
     void clearTasks(const Utils::FilePath &filePath);
-    Utils::optional<bool> hasVirtualFunctionAt(TextEditor::TextDocument *doc, int revision,
+    std::optional<bool> hasVirtualFunctionAt(TextEditor::TextDocument *doc, int revision,
                                                const LanguageServerProtocol::Range &range);
 
     using TextDocOrFile = std::variant<const TextEditor::TextDocument *, Utils::FilePath>;
@@ -136,7 +137,7 @@ class ClangdDiagnostic : public LanguageServerProtocol::Diagnostic
 {
 public:
     using Diagnostic::Diagnostic;
-    Utils::optional<QList<LanguageServerProtocol::CodeAction>> codeActions() const;
+    std::optional<QList<LanguageServerProtocol::CodeAction>> codeActions() const;
     QString category() const;
 };
 
diff --git a/src/plugins/clangcodemodel/clangdcompletion.cpp b/src/plugins/clangcodemodel/clangdcompletion.cpp
index b82a046821..d99e9ae92f 100644
--- a/src/plugins/clangcodemodel/clangdcompletion.cpp
+++ b/src/plugins/clangcodemodel/clangdcompletion.cpp
@@ -336,7 +336,7 @@ void ClangdCompletionItem::apply(TextDocumentManipulatorInterface &manipulator,
 
 ClangdCompletionItem::SpecialQtType ClangdCompletionItem::getQtType(const CompletionItem &item)
 {
-    const Utils::optional<MarkupOrString> doc = item.documentation();
+    const std::optional<MarkupOrString> doc = item.documentation();
     if (!doc)
         return SpecialQtType::None;
     QString docText;
@@ -612,7 +612,7 @@ ClangdCompletionCapabilities::ClangdCompletionCapabilities(const JsonObject &obj
     : TextDocumentClientCapabilities::CompletionCapabilities(object)
 {
     insert(u"editsNearCursor", true); // For dot-to-arrow correction.
-    if (Utils::optional<CompletionItemCapbilities> completionItemCaps = completionItem()) {
+    if (std::optional<CompletionItemCapbilities> completionItemCaps = completionItem()) {
         completionItemCaps->setSnippetSupport(false);
         setCompletionItem(*completionItemCaps);
     }
diff --git a/src/plugins/clangcodemodel/clangdfindreferences.cpp b/src/plugins/clangcodemodel/clangdfindreferences.cpp
index de4d79c85c..932b50fefa 100644
--- a/src/plugins/clangcodemodel/clangdfindreferences.cpp
+++ b/src/plugins/clangcodemodel/clangdfindreferences.cpp
@@ -65,21 +65,21 @@ public:
     void finishSearch();
     void reportAllSearchResultsAndFinish();
     void addSearchResultsForFile(const FilePath &file, const ReferencesFileData &fileData);
-    Utils::optional<QString> getContainingFunctionName(const ClangdAstPath &astPath,
+    std::optional<QString> getContainingFunctionName(const ClangdAstPath &astPath,
                                                        const Range& range);
 
     ClangdFindReferences * const q;
     QMap<DocumentUri, ReferencesFileData> fileData;
     QList<MessageId> pendingAstRequests;
     QPointer<SearchResult> search;
-    Utils::optional<ReplacementData> replacementData;
+    std::optional<ReplacementData> replacementData;
     bool canceled = false;
     bool categorize = false;
 };
 
 ClangdFindReferences::ClangdFindReferences(ClangdClient *client, TextDocument *document,
         const QTextCursor &cursor, const QString &searchTerm,
-        const Utils::optional<QString> &replacement, bool categorize)
+        const std::optional<QString> &replacement, bool categorize)
     : QObject(client), d(new ClangdFindReferences::Private(this))
 {
     d->categorize = categorize;
@@ -121,7 +121,7 @@ ClangdFindReferences::ClangdFindReferences(ClangdClient *client, TextDocument *d
     });
     SearchResultWindow::instance()->popup(IOutputPane::ModeSwitch | IOutputPane::WithFocus);
 
-    const Utils::optional<MessageId> requestId = client->symbolSupport().findUsages(
+    const std::optional<MessageId> requestId = client->symbolSupport().findUsages(
                 document, cursor, [self = QPointer(this)](const QList<Location> &locations) {
         if (self)
             self->d->handleFindUsagesResult(locations);
@@ -324,7 +324,7 @@ void ClangdFindReferences::Private::addSearchResultsForFile(const FilePath &file
         search->addResults(items, SearchResult::AddOrdered);
 }
 
-Utils::optional<QString> ClangdFindReferences::Private::getContainingFunctionName(
+std::optional<QString> ClangdFindReferences::Private::getContainingFunctionName(
     const ClangdAstPath &astPath, const Range& range)
 {
     const ClangdAstNode* containingFuncNode{nullptr};
@@ -344,7 +344,7 @@ Utils::optional<QString> ClangdFindReferences::Private::getContainingFunctionNam
     }
 
     if (!containingFuncNode || !containingFuncNode->isValid())
-        return Utils::nullopt;
+        return std::nullopt;
 
     return containingFuncNode->detail();
 }
diff --git a/src/plugins/clangcodemodel/clangdfindreferences.h b/src/plugins/clangcodemodel/clangdfindreferences.h
index 8d99edaa84..f45a61b25e 100644
--- a/src/plugins/clangcodemodel/clangdfindreferences.h
+++ b/src/plugins/clangcodemodel/clangdfindreferences.h
@@ -5,10 +5,11 @@
 
 #include <coreplugin/find/searchresultitem.h>
 #include <cppeditor/cursorineditor.h>
-#include <utils/optional.h>
 
 #include <QObject>
 
+#include <optional>
+
 QT_BEGIN_NAMESPACE
 class QTextCursor;
 QT_END_NAMESPACE
@@ -24,7 +25,7 @@ class ClangdFindReferences : public QObject
 public:
     explicit ClangdFindReferences(ClangdClient *client, TextEditor::TextDocument *document,
                                   const QTextCursor &cursor, const QString &searchTerm,
-                                  const Utils::optional<QString> &replacement, bool categorize);
+                                  const std::optional<QString> &replacement, bool categorize);
     ~ClangdFindReferences();
 
 signals:
diff --git a/src/plugins/clangcodemodel/clangdfollowsymbol.cpp b/src/plugins/clangcodemodel/clangdfollowsymbol.cpp
index a2b2916d38..49cbef3682 100644
--- a/src/plugins/clangcodemodel/clangdfollowsymbol.cpp
+++ b/src/plugins/clangcodemodel/clangdfollowsymbol.cpp
@@ -107,7 +107,7 @@ public:
     Link defLink;
     Links allLinks;
     QHash<Link, Link> declDefMap;
-    optional<ClangdAstNode> cursorNode;
+    std::optional<ClangdAstNode> cursorNode;
     ClangdAstNode defLinkNode;
     SymbolDataList symbolsToDisplay;
     std::set<FilePath> openedFiles;
@@ -375,7 +375,7 @@ void ClangdFollowSymbol::Private::handleGotoDefinitionResult()
 void ClangdFollowSymbol::Private::handleGotoImplementationResult(
         const GotoImplementationRequest::Response &response)
 {
-    if (const optional<GotoResult> &result = response.result()) {
+    if (const std::optional<GotoResult> &result = response.result()) {
         QList<Link> newLinks;
         if (const auto ploc = std::get_if<Location>(&*result))
             newLinks = {ploc->toLink()};
@@ -451,7 +451,7 @@ void ClangdFollowSymbol::Private::handleGotoImplementationResult(
             if (!sentinel)
                 return;
             Link newLink;
-            if (optional<GotoResult> _result = response.result()) {
+            if (std::optional<GotoResult> _result = response.result()) {
                 const GotoResult result = _result.value();
                 if (const auto ploc = std::get_if<Location>(&result)) {
                     newLink = ploc->toLink();
diff --git a/src/plugins/clangcodemodel/clangdmemoryusagewidget.cpp b/src/plugins/clangcodemodel/clangdmemoryusagewidget.cpp
index 429ebfe791..06ec53d621 100644
--- a/src/plugins/clangcodemodel/clangdmemoryusagewidget.cpp
+++ b/src/plugins/clangcodemodel/clangdmemoryusagewidget.cpp
@@ -131,7 +131,7 @@ public:
     const QPointer<ClangdClient> client;
     MemoryTreeModel model;
     TreeView view;
-    Utils::optional<MessageId> currentRequest;
+    std::optional<MessageId> currentRequest;
 };
 
 ClangdMemoryUsageWidget::ClangdMemoryUsageWidget(ClangdClient *client)
diff --git a/src/plugins/clangcodemodel/clangdquickfixes.cpp b/src/plugins/clangcodemodel/clangdquickfixes.cpp
index 6b6f7676ce..83ad6a0d80 100644
--- a/src/plugins/clangcodemodel/clangdquickfixes.cpp
+++ b/src/plugins/clangcodemodel/clangdquickfixes.cpp
@@ -65,7 +65,7 @@ private:
         auto toOperation =
             [=](const std::variant<Command, CodeAction> &item) -> QuickFixOperation * {
             if (auto action = std::get_if<CodeAction>(&item)) {
-                const Utils::optional<QList<Diagnostic>> diagnostics = action->diagnostics();
+                const std::optional<QList<Diagnostic>> diagnostics = action->diagnostics();
                 if (!diagnostics.has_value() || diagnostics->isEmpty())
                     return new CodeActionQuickFixOperation(*action, client());
             }
diff --git a/src/plugins/clangcodemodel/clangdswitchdecldef.cpp b/src/plugins/clangcodemodel/clangdswitchdecldef.cpp
index c39553259c..7773e7fa0e 100644
--- a/src/plugins/clangcodemodel/clangdswitchdecldef.cpp
+++ b/src/plugins/clangcodemodel/clangdswitchdecldef.cpp
@@ -10,12 +10,13 @@
 #include <languageclient/documentsymbolcache.h>
 #include <languageserverprotocol/lsptypes.h>
 #include <texteditor/textdocument.h>
-#include <utils/optional.h>
 #include <utils/qtcassert.h>
 
 #include <QApplication>
 #include <QTextCursor>
 
+#include <optional>
+
 using namespace CppEditor;
 using namespace LanguageClient;
 using namespace LanguageServerProtocol;
@@ -33,7 +34,7 @@ public:
           cursor(cursor), editorWidget(editorWidget), callback(callback)
     {}
 
-    optional<ClangdAstNode> getFunctionNode() const;
+    std::optional<ClangdAstNode> getFunctionNode() const;
     QTextCursor cursorForFunctionName(const ClangdAstNode &functionNode) const;
     void handleDeclDefSwitchReplies();
 
@@ -44,8 +45,8 @@ public:
     const QTextCursor cursor;
     const QPointer<CppEditorWidget> editorWidget;
     const LinkHandler callback;
-    optional<ClangdAstNode> ast;
-    optional<DocumentSymbolsResult> docSymbols;
+    std::optional<ClangdAstNode> ast;
+    std::optional<DocumentSymbolsResult> docSymbols;
     bool done = false;
 };
 
@@ -110,7 +111,7 @@ void ClangdSwitchDeclDef::emitDone()
     emit done();
 }
 
-optional<ClangdAstNode> ClangdSwitchDeclDef::Private::getFunctionNode() const
+std::optional<ClangdAstNode> ClangdSwitchDeclDef::Private::getFunctionNode() const
 {
     QTC_ASSERT(ast, return {});
 
@@ -157,7 +158,7 @@ void ClangdSwitchDeclDef::Private::handleDeclDefSwitchReplies()
     // on a function return type, or ...
     if (clangdLogAst().isDebugEnabled())
         ast->print(0);
-    const Utils::optional<ClangdAstNode> functionNode = getFunctionNode();
+    const std::optional<ClangdAstNode> functionNode = getFunctionNode();
     if (!functionNode) {
         q->emitDone();
         return;
diff --git a/src/plugins/clangcodemodel/clangtextmark.cpp b/src/plugins/clangcodemodel/clangtextmark.cpp
index 47028c37c6..e5ef9f4d81 100644
--- a/src/plugins/clangcodemodel/clangtextmark.cpp
+++ b/src/plugins/clangcodemodel/clangtextmark.cpp
@@ -215,10 +215,10 @@ ClangDiagnostic convertDiagnostic(const ClangdDiagnostic &src, const FilePath &f
     if (codeString && codeString->startsWith("-W"))
         target.enableOption = *codeString;
     for (const CodeAction &codeAction : src.codeActions().value_or(QList<CodeAction>())) {
-        const Utils::optional<WorkspaceEdit> edit = codeAction.edit();
+        const std::optional<WorkspaceEdit> edit = codeAction.edit();
         if (!edit)
             continue;
-        const Utils::optional<WorkspaceEdit::Changes> changes = edit->changes();
+        const std::optional<WorkspaceEdit::Changes> changes = edit->changes();
         if (!changes)
             continue;
         ClangDiagnostic fixItDiag;
diff --git a/src/plugins/clangformat/clangformatbaseindenter.cpp b/src/plugins/clangformat/clangformatbaseindenter.cpp
index 7fa4ac9cb1..34039583ed 100644
--- a/src/plugins/clangformat/clangformatbaseindenter.cpp
+++ b/src/plugins/clangformat/clangformatbaseindenter.cpp
@@ -706,7 +706,7 @@ bool ClangFormatBaseIndenter::isElectricCharacter(const QChar &ch) const
     return false;
 }
 
-Utils::optional<int> ClangFormat::ClangFormatBaseIndenter::margin() const
+std::optional<int> ClangFormat::ClangFormatBaseIndenter::margin() const
 {
     return styleForFile().ColumnLimit;
 }
diff --git a/src/plugins/clangformat/clangformatbaseindenter.h b/src/plugins/clangformat/clangformatbaseindenter.h
index 7174a0b4af..aa5290f4ff 100644
--- a/src/plugins/clangformat/clangformatbaseindenter.h
+++ b/src/plugins/clangformat/clangformatbaseindenter.h
@@ -44,7 +44,7 @@ public:
 
     bool isElectricCharacter(const QChar &ch) const override;
 
-    Utils::optional<int> margin() const override;
+    std::optional<int> margin() const override;
 
     clang::format::FormatStyle styleForFile() const;
 
diff --git a/src/plugins/clangformat/clangformatindenter.cpp b/src/plugins/clangformat/clangformatindenter.cpp
index 75383a1bc7..8328d3fdfb 100644
--- a/src/plugins/clangformat/clangformatindenter.cpp
+++ b/src/plugins/clangformat/clangformatindenter.cpp
@@ -55,7 +55,7 @@ bool ClangFormatIndenter::formatCodeInsteadOfIndent() const
     return ClangFormatSettings::instance().mode() == ClangFormatSettings::Mode::Formatting;
 }
 
-Utils::optional<TabSettings> ClangFormatIndenter::tabSettings() const
+std::optional<TabSettings> ClangFormatIndenter::tabSettings() const
 {
     FormatStyle style = styleForFile();
     TabSettings tabSettings;
diff --git a/src/plugins/clangformat/clangformatindenter.h b/src/plugins/clangformat/clangformatindenter.h
index 438ab2a0bd..0303b3c066 100644
--- a/src/plugins/clangformat/clangformatindenter.h
+++ b/src/plugins/clangformat/clangformatindenter.h
@@ -13,7 +13,7 @@ class ClangFormatIndenter final : public ClangFormatBaseIndenter
 {
 public:
     ClangFormatIndenter(QTextDocument *doc);
-    Utils::optional<TextEditor::TabSettings> tabSettings() const override;
+    std::optional<TextEditor::TabSettings> tabSettings() const override;
     bool formatOnSave() const override;
 
 private:
diff --git a/src/plugins/clangformat/tests/clangformat-test.cpp b/src/plugins/clangformat/tests/clangformat-test.cpp
index ede1768783..74107a40e7 100644
--- a/src/plugins/clangformat/tests/clangformat-test.cpp
+++ b/src/plugins/clangformat/tests/clangformat-test.cpp
@@ -7,12 +7,13 @@
 
 #include <texteditor/tabsettings.h>
 #include <utils/fileutils.h>
-#include <utils/optional.h>
 
 #include <QTextCursor>
 #include <QTextDocument>
 #include <QtTest>
 
+#include <optional>
+
 namespace ClangFormat::Internal {
 
 class ClangFormatTestIndenter : public ClangFormatBaseIndenter
@@ -21,7 +22,7 @@ public:
     ClangFormatTestIndenter(QTextDocument *doc) : ClangFormatBaseIndenter(doc) {}
 
 private:
-    Utils::optional<TextEditor::TabSettings> tabSettings() const override { return {}; }
+    std::optional<TextEditor::TabSettings> tabSettings() const override { return {}; }
 };
 
 class ClangFormatExtendedTestIndenter : public ClangFormatTestIndenter
diff --git a/src/plugins/clangtools/clangtoolsdiagnosticmodel.h b/src/plugins/clangtools/clangtoolsdiagnosticmodel.h
index 5eb7740e50..0fa4c97bda 100644
--- a/src/plugins/clangtools/clangtoolsdiagnosticmodel.h
+++ b/src/plugins/clangtools/clangtoolsdiagnosticmodel.h
@@ -10,7 +10,6 @@
 
 #include <debugger/analyzer/detailederrorview.h>
 #include <utils/fileutils.h>
-#include <utils/optional.h>
 #include <utils/treemodel.h>
 
 #include <QFileSystemWatcher>
@@ -21,6 +20,7 @@
 #include <functional>
 #include <map>
 #include <memory>
+#include <optional>
 
 namespace ProjectExplorer { class Project; }
 
@@ -127,7 +127,7 @@ class FilterOptions {
 public:
     QSet<QString> checks;
 };
-using OptionalFilterOptions = Utils::optional<FilterOptions>;
+using OptionalFilterOptions = std::optional<FilterOptions>;
 
 class DiagnosticFilterModel : public QSortFilterProxyModel
 {
diff --git a/src/plugins/clangtools/clangtoolslogfilereader.cpp b/src/plugins/clangtools/clangtoolslogfilereader.cpp
index debba17ba8..5ab8755bfc 100644
--- a/src/plugins/clangtools/clangtoolslogfilereader.cpp
+++ b/src/plugins/clangtools/clangtoolslogfilereader.cpp
@@ -31,7 +31,7 @@ static bool checkFilePath(const Utils::FilePath &filePath, QString *errorMessage
     return true;
 }
 
-Utils::optional<LineColumnInfo> byteOffsetInUtf8TextToLineColumn(const char *text,
+std::optional<LineColumnInfo> byteOffsetInUtf8TextToLineColumn(const char *text,
                                                                  int offset,
                                                                  int startLine)
 {
diff --git a/src/plugins/clangtools/clangtoolslogfilereader.h b/src/plugins/clangtools/clangtoolslogfilereader.h
index 4a069381c2..fb062f3b8e 100644
--- a/src/plugins/clangtools/clangtoolslogfilereader.h
+++ b/src/plugins/clangtools/clangtoolslogfilereader.h
@@ -3,10 +3,11 @@
 
 #pragma once
 
-#include <utils/optional.h>
 
 #include "clangtoolsdiagnostic.h"
 
+#include <optional>
+
 namespace Utils { class FilePath; }
 
 namespace ClangTools {
@@ -27,7 +28,7 @@ struct LineColumnInfo {
     int column = 1; // 1-based
     int lineStartOffset = 0; // for optimiation/caching purposes
 };
-using OptionalLineColumnInfo = Utils::optional<LineColumnInfo>;
+using OptionalLineColumnInfo = std::optional<LineColumnInfo>;
 OptionalLineColumnInfo byteOffsetInUtf8TextToLineColumn(const char *text,
                                                         int offset,
                                                         int startLine = 1);
diff --git a/src/plugins/clangtools/clangtoolsutils.cpp b/src/plugins/clangtools/clangtoolsutils.cpp
index 5b30f7fc76..741e5de9f9 100644
--- a/src/plugins/clangtools/clangtoolsutils.cpp
+++ b/src/plugins/clangtools/clangtoolsutils.cpp
@@ -54,7 +54,7 @@ static QString fixitStatus(FixitStatus status)
 
 QString createDiagnosticToolTipString(
     const Diagnostic &diagnostic,
-    Utils::optional<FixitStatus> status,
+    std::optional<FixitStatus> status,
     bool showSteps)
 {
     using StringPair = QPair<QString, QString>;
diff --git a/src/plugins/clangtools/clangtoolsutils.h b/src/plugins/clangtools/clangtoolsutils.h
index 176bbd5ea1..ed6c60603b 100644
--- a/src/plugins/clangtools/clangtoolsutils.h
+++ b/src/plugins/clangtools/clangtoolsutils.h
@@ -6,10 +6,11 @@
 #include <cppeditor/clangdiagnosticconfig.h>
 
 #include <utils/id.h>
-#include <utils/optional.h>
 
 #include <QtGlobal>
 
+#include <optional>
+
 namespace CppEditor { class ClangDiagnosticConfigsModel; }
 namespace Debugger { class DiagnosticLocation; }
 namespace Utils { class FilePath; }
@@ -31,10 +32,9 @@ enum class FixitStatus {
     Invalidated,
 };
 
-QString createDiagnosticToolTipString(
-    const Diagnostic &diagnostic,
-    Utils::optional<FixitStatus> status = Utils::nullopt,
-    bool showSteps = true);
+QString createDiagnosticToolTipString(const Diagnostic &diagnostic,
+                                      std::optional<FixitStatus> status = std::nullopt,
+                                      bool showSteps = true);
 
 CppEditor::ClangDiagnosticConfig builtinConfig();
 
diff --git a/src/plugins/clangtools/diagnosticmark.cpp b/src/plugins/clangtools/diagnosticmark.cpp
index 3fe52d4762..2b8cd472db 100644
--- a/src/plugins/clangtools/diagnosticmark.cpp
+++ b/src/plugins/clangtools/diagnosticmark.cpp
@@ -30,7 +30,7 @@ DiagnosticMark::DiagnosticMark(const Diagnostic &diagnostic)
     setPriority(TextEditor::TextMark::HighPriority);
     QIcon markIcon = diagnostic.icon();
     setIcon(markIcon.isNull() ? Utils::Icons::CODEMODEL_WARNING.icon() : markIcon);
-    setToolTip(createDiagnosticToolTipString(diagnostic, Utils::nullopt,  true));
+    setToolTip(createDiagnosticToolTipString(diagnostic, std::nullopt, true));
     setLineAnnotation(diagnostic.description);
     setActionsProvider([diagnostic] {
         // Copy to clipboard action
diff --git a/src/plugins/clangtools/settingswidget.cpp b/src/plugins/clangtools/settingswidget.cpp
index 738e600a97..7c667d6ee6 100644
--- a/src/plugins/clangtools/settingswidget.cpp
+++ b/src/plugins/clangtools/settingswidget.cpp
@@ -13,7 +13,7 @@
 
 #include <debugger/analyzer/analyzericons.h>
 
-#include <utils/optional.h>
+#include <optional>
 
 using namespace Utils;
 
diff --git a/src/plugins/cmakeprojectmanager/cmakebuildconfiguration.cpp b/src/plugins/cmakeprojectmanager/cmakebuildconfiguration.cpp
index 0e7924efaf..36736b6f9d 100644
--- a/src/plugins/cmakeprojectmanager/cmakebuildconfiguration.cpp
+++ b/src/plugins/cmakeprojectmanager/cmakebuildconfiguration.cpp
@@ -1188,7 +1188,7 @@ CMakeBuildConfiguration::CMakeBuildConfiguration(Target *target, Id id)
 
     const auto buildDirAspect = aspect<BuildDirectoryAspect>();
     buildDirAspect->setValueAcceptor(
-        [](const QString &oldDir, const QString &newDir) -> Utils::optional<QString> {
+        [](const QString &oldDir, const QString &newDir) -> std::optional<QString> {
             if (oldDir.isEmpty())
                 return newDir;
 
@@ -1204,7 +1204,7 @@ CMakeBuildConfiguration::CMakeBuildConfiguration(Target *target, Id id)
                     == QMessageBox::Ok) {
                     return newDir;
                 }
-                return Utils::nullopt;
+                return std::nullopt;
             }
             return newDir;
         });
diff --git a/src/plugins/cmakeprojectmanager/cmakeconfigitem.cpp b/src/plugins/cmakeprojectmanager/cmakeconfigitem.cpp
index dbf5f6f3d5..28dadbcd99 100644
--- a/src/plugins/cmakeprojectmanager/cmakeconfigitem.cpp
+++ b/src/plugins/cmakeprojectmanager/cmakeconfigitem.cpp
@@ -166,7 +166,7 @@ QString CMakeConfigItem::typeToTypeString(const CMakeConfigItem::Type t)
     return {};
 }
 
-Utils::optional<bool> CMakeConfigItem::toBool(const QString &value)
+std::optional<bool> CMakeConfigItem::toBool(const QString &value)
 {
     // Taken from CMakes if(<constant>) documentation:
     // "Named boolean constants are case-insensitive."
diff --git a/src/plugins/cmakeprojectmanager/cmakeconfigitem.h b/src/plugins/cmakeprojectmanager/cmakeconfigitem.h
index f808b55de6..afec217cd1 100644
--- a/src/plugins/cmakeprojectmanager/cmakeconfigitem.h
+++ b/src/plugins/cmakeprojectmanager/cmakeconfigitem.h
@@ -5,11 +5,12 @@
 
 #include "cmake_global.h"
 
-#include <utils/optional.h>
 
 #include <QByteArray>
 #include <QStringList>
 
+#include <optional>
+
 namespace Utils {
 class FilePath;
 class MacroExpander;
@@ -33,7 +34,7 @@ public:
     static QStringList cmakeSplitValue(const QString &in, bool keepEmpty = false);
     static Type typeStringToType(const QByteArray &typeString);
     static QString typeToTypeString(const Type t);
-    static Utils::optional<bool> toBool(const QString &value);
+    static std::optional<bool> toBool(const QString &value);
     bool isNull() const { return key.isEmpty(); }
 
     QString expandedValue(const ProjectExplorer::Kit *k) const;
diff --git a/src/plugins/cmakeprojectmanager/cmakeparser.h b/src/plugins/cmakeprojectmanager/cmakeparser.h
index 3cb349d2ca..686840575e 100644
--- a/src/plugins/cmakeprojectmanager/cmakeparser.h
+++ b/src/plugins/cmakeprojectmanager/cmakeparser.h
@@ -8,11 +8,11 @@
 #include <projectexplorer/ioutputparser.h>
 #include <projectexplorer/task.h>
 
-#include <utils/optional.h>
-
 #include <QDir>
 #include <QRegularExpression>
 
+#include <optional>
+
 namespace CMakeProjectManager {
 
 class CMAKE_EXPORT CMakeParser : public ProjectExplorer::OutputTaskParser
@@ -31,7 +31,7 @@ private:
 
     TripleLineError m_expectTripleLineErrorData = NONE;
 
-    Utils::optional<QDir> m_sourceDirectory;
+    std::optional<QDir> m_sourceDirectory;
     ProjectExplorer::Task m_lastTask;
     QRegularExpression m_commonError;
     QRegularExpression m_nextSubError;
diff --git a/src/plugins/cmakeprojectmanager/cmakeprojectnodes.cpp b/src/plugins/cmakeprojectmanager/cmakeprojectnodes.cpp
index c591e903de..3cb364a08a 100644
--- a/src/plugins/cmakeprojectmanager/cmakeprojectnodes.cpp
+++ b/src/plugins/cmakeprojectmanager/cmakeprojectnodes.cpp
@@ -39,7 +39,7 @@ bool CMakeListsNode::showInSimpleTree() const
     return false;
 }
 
-Utils::optional<Utils::FilePath> CMakeListsNode::visibleAfterAddFileAction() const
+std::optional<Utils::FilePath> CMakeListsNode::visibleAfterAddFileAction() const
 {
     return filePath().pathAppended("CMakeLists.txt");
 }
@@ -169,7 +169,7 @@ void CMakeTargetNode::setConfig(const CMakeConfig &config)
     m_config = config;
 }
 
-Utils::optional<Utils::FilePath> CMakeTargetNode::visibleAfterAddFileAction() const
+std::optional<Utils::FilePath> CMakeTargetNode::visibleAfterAddFileAction() const
 {
     return filePath().pathAppended("CMakeLists.txt");
 }
diff --git a/src/plugins/cmakeprojectmanager/cmakeprojectnodes.h b/src/plugins/cmakeprojectmanager/cmakeprojectnodes.h
index 9434da0e55..05f081bf99 100644
--- a/src/plugins/cmakeprojectmanager/cmakeprojectnodes.h
+++ b/src/plugins/cmakeprojectmanager/cmakeprojectnodes.h
@@ -22,7 +22,7 @@ public:
     CMakeListsNode(const Utils::FilePath &cmakeListPath);
 
     bool showInSimpleTree() const final;
-    Utils::optional<Utils::FilePath> visibleAfterAddFileAction() const override;
+    std::optional<Utils::FilePath> visibleAfterAddFileAction() const override;
 };
 
 class CMakeProjectNode : public ProjectExplorer::ProjectNode
@@ -45,7 +45,7 @@ public:
     Utils::FilePath buildDirectory() const;
     void setBuildDirectory(const Utils::FilePath &directory);
 
-    Utils::optional<Utils::FilePath> visibleAfterAddFileAction() const override;
+    std::optional<Utils::FilePath> visibleAfterAddFileAction() const override;
 
     void build() override;
 
diff --git a/src/plugins/cmakeprojectmanager/cmaketool.cpp b/src/plugins/cmakeprojectmanager/cmaketool.cpp
index 7165ceab26..7b9f699f06 100644
--- a/src/plugins/cmakeprojectmanager/cmaketool.cpp
+++ b/src/plugins/cmakeprojectmanager/cmaketool.cpp
@@ -49,7 +49,7 @@ namespace Internal {
 
 const char READER_TYPE_FILEAPI[] = "fileapi";
 
-static Utils::optional<CMakeTool::ReaderType> readerTypeFromString(const QString &input)
+static std::optional<CMakeTool::ReaderType> readerTypeFromString(const QString &input)
 {
     // Do not try to be clever here, just use whatever is in the string!
     if (input == READER_TYPE_FILEAPI)
@@ -331,7 +331,7 @@ CMakeTool::PathMapper CMakeTool::pathMapper() const
     return [](const FilePath &fn) { return fn; };
 }
 
-Utils::optional<CMakeTool::ReaderType> CMakeTool::readerType() const
+std::optional<CMakeTool::ReaderType> CMakeTool::readerType() const
 {
     if (m_readerType)
         return m_readerType; // Allow overriding the auto-detected value via .user files
diff --git a/src/plugins/cmakeprojectmanager/cmaketool.h b/src/plugins/cmakeprojectmanager/cmaketool.h
index 9d1f1fe197..94e122d204 100644
--- a/src/plugins/cmakeprojectmanager/cmaketool.h
+++ b/src/plugins/cmakeprojectmanager/cmaketool.h
@@ -9,7 +9,8 @@
 
 #include <utils/fileutils.h>
 #include <utils/id.h>
-#include <utils/optional.h>
+
+#include <optional>
 
 namespace Utils { class QtcProcess; }
 
@@ -83,7 +84,7 @@ public:
     void setPathMapper(const PathMapper &includePathMapper);
     PathMapper pathMapper() const;
 
-    Utils::optional<ReaderType> readerType() const;
+    std::optional<ReaderType> readerType() const;
 
     static Utils::FilePath searchQchFile(const Utils::FilePath &executable);
 
@@ -115,7 +116,7 @@ private:
     QString m_detectionSource;
     bool m_autoCreateBuildDirectory = false;
 
-    Utils::optional<ReaderType> m_readerType;
+    std::optional<ReaderType> m_readerType;
 
     std::unique_ptr<Internal::IntrospectionData> m_introspection;
 
diff --git a/src/plugins/cmakeprojectmanager/fileapidataextractor.h b/src/plugins/cmakeprojectmanager/fileapidataextractor.h
index 4e7308cc2f..fbecc237c9 100644
--- a/src/plugins/cmakeprojectmanager/fileapidataextractor.h
+++ b/src/plugins/cmakeprojectmanager/fileapidataextractor.h
@@ -9,13 +9,13 @@
 #include <projectexplorer/rawprojectpart.h>
 
 #include <utils/fileutils.h>
-#include <utils/optional.h>
 
 #include <QList>
 #include <QSet>
 #include <QString>
 
 #include <memory>
+#include <optional>
 
 namespace CMakeProjectManager {
 namespace Internal {
diff --git a/src/plugins/cmakeprojectmanager/fileapiparser.h b/src/plugins/cmakeprojectmanager/fileapiparser.h
index aab05cb7da..acd31d77fe 100644
--- a/src/plugins/cmakeprojectmanager/fileapiparser.h
+++ b/src/plugins/cmakeprojectmanager/fileapiparser.h
@@ -195,8 +195,8 @@ public:
     QList<Utils::FilePath> artifacts;
     QString installPrefix;
     std::vector<InstallDestination> installDestination;
-    Utils::optional<LinkInfo> link;
-    Utils::optional<ArchiveInfo> archive;
+    std::optional<LinkInfo> link;
+    std::optional<ArchiveInfo> archive;
     std::vector<DependencyInfo> dependencies;
     std::vector<SourceInfo> sources;
     std::vector<QString> sourceGroups;
diff --git a/src/plugins/cmakeprojectmanager/fileapireader.h b/src/plugins/cmakeprojectmanager/fileapireader.h
index 3e362423be..6f59a17ddd 100644
--- a/src/plugins/cmakeprojectmanager/fileapireader.h
+++ b/src/plugins/cmakeprojectmanager/fileapireader.h
@@ -12,13 +12,13 @@
 #include <projectexplorer/treescanner.h>
 
 #include <utils/filesystemwatcher.h>
-#include <utils/optional.h>
 
 #include <QDateTime>
 #include <QFuture>
 #include <QObject>
 
 #include <memory>
+#include <optional>
 
 namespace ProjectExplorer {
 class ProjectNode;
@@ -92,7 +92,7 @@ private:
     bool m_usesAllCapsTargets = false;
     int m_lastCMakeExitCode = 0;
 
-    Utils::optional<QFuture<std::shared_ptr<FileApiQtcData>>> m_future;
+    std::optional<QFuture<std::shared_ptr<FileApiQtcData>>> m_future;
 
     // Update related:
     bool m_isParsing = false;
diff --git a/src/plugins/coco/cocolanguageclient.cpp b/src/plugins/coco/cocolanguageclient.cpp
index aa79ec1289..8db497d10e 100644
--- a/src/plugins/coco/cocolanguageclient.cpp
+++ b/src/plugins/coco/cocolanguageclient.cpp
@@ -119,11 +119,11 @@ class CocoDiagnostic : public Diagnostic
 {
 public:
     using Diagnostic::Diagnostic;
-    optional<CocoDiagnosticSeverity> cocoSeverity() const
+    std::optional<CocoDiagnosticSeverity> cocoSeverity() const
     {
         if (auto val = optionalValue<int>(severityKey))
-            return Utils::make_optional(static_cast<CocoDiagnosticSeverity>(*val));
-        return Utils::nullopt;
+            return std::make_optional(static_cast<CocoDiagnosticSeverity>(*val));
+        return std::nullopt;
     }
 };
 
@@ -154,7 +154,7 @@ public:
         }
     }
 
-    optional<CocoDiagnosticSeverity> m_severity;
+    std::optional<CocoDiagnosticSeverity> m_severity;
     QColor m_annotationColor;
 };
 
@@ -185,7 +185,7 @@ private:
                                          bool /*isProjectFile*/) const override
     {
         const CocoDiagnostic cocoDiagnostic(diagnostic);
-        if (optional<CocoDiagnosticSeverity> severity = cocoDiagnostic.cocoSeverity())
+        if (std::optional<CocoDiagnosticSeverity> severity = cocoDiagnostic.cocoSeverity())
             return new CocoTextMark(filePath, cocoDiagnostic, client()->id());
         return nullptr;
     }
@@ -193,7 +193,8 @@ private:
     QTextEdit::ExtraSelection createDiagnosticSelection(const Diagnostic &diagnostic,
                                                         QTextDocument *textDocument) const override
     {
-        if (optional<CocoDiagnosticSeverity> severity = CocoDiagnostic(diagnostic).cocoSeverity()) {
+        if (std::optional<CocoDiagnosticSeverity> severity = CocoDiagnostic(diagnostic)
+                                                                 .cocoSeverity()) {
             QTextCursor cursor(textDocument);
             cursor.setPosition(diagnostic.range().start().toPositionInDocument(textDocument));
             cursor.setPosition(diagnostic.range().end().toPositionInDocument(textDocument),
@@ -210,7 +211,7 @@ private:
 
     void setDiagnostics(const DocumentUri &uri,
                         const QList<Diagnostic> &diagnostics,
-                        const Utils::optional<int> &version) override
+                        const std::optional<int> &version) override
     {
         DiagnosticManager::setDiagnostics(uri, diagnostics, version);
         showDiagnostics(uri, client()->documentVersion(uri.toFilePath()));
diff --git a/src/plugins/compilationdatabaseprojectmanager/compilationdatabaseutils.cpp b/src/plugins/compilationdatabaseprojectmanager/compilationdatabaseutils.cpp
index 187acaa2bb..e503c47729 100644
--- a/src/plugins/compilationdatabaseprojectmanager/compilationdatabaseutils.cpp
+++ b/src/plugins/compilationdatabaseprojectmanager/compilationdatabaseutils.cpp
@@ -8,13 +8,14 @@
 
 #include <utils/algorithm.h>
 #include <utils/hostosinfo.h>
-#include <utils/optional.h>
 #include <utils/stringutils.h>
 
 #include <QDir>
 #include <QRegularExpression>
 #include <QSet>
 
+#include <optional>
+
 using namespace ProjectExplorer;
 using namespace Utils;
 
@@ -100,8 +101,8 @@ void filteredFlags(const QString &fileName,
     bool skipNext = Utils::HostOsInfo::isWindowsHost()
                 ? (!flags.front().startsWith('/') && !flags.front().startsWith('-'))
                 : (!flags.front().startsWith('-'));
-    Utils::optional<HeaderPathType> includePathType;
-    Utils::optional<MacroType> macroType;
+    std::optional<HeaderPathType> includePathType;
+    std::optional<MacroType> macroType;
     bool fileKindIsNext = false;
 
     QStringList filtered;
diff --git a/src/plugins/coreplugin/documentmanager.cpp b/src/plugins/coreplugin/documentmanager.cpp
index d46044c8a3..13698bb50f 100644
--- a/src/plugins/coreplugin/documentmanager.cpp
+++ b/src/plugins/coreplugin/documentmanager.cpp
@@ -30,7 +30,6 @@
 #include <utils/globalfilechangeblocker.h>
 #include <utils/hostosinfo.h>
 #include <utils/mimeutils.h>
-#include <utils/optional.h>
 #include <utils/pathchooser.h>
 #include <utils/qtcassert.h>
 #include <utils/reloadpromptutils.h>
@@ -52,6 +51,8 @@
 #include <QStringList>
 #include <QTimer>
 
+#include <optional>
+
 static const bool kUseProjectsDirectoryDefault = true;
 static Q_LOGGING_CATEGORY(log, "qtc.core.documentmanager", QtWarningMsg)
 
@@ -1131,7 +1132,7 @@ void DocumentManager::checkForReload()
     QStringList filesToDiff;
     for (IDocument *document : qAsConst(changedIDocuments)) {
         IDocument::ChangeTrigger trigger = IDocument::TriggerInternal;
-        optional<IDocument::ChangeType> type;
+        std::optional<IDocument::ChangeType> type;
         bool changed = false;
         // find out the type & behavior from the two possible files
         // behavior is internal if all changes are expected (and none removed)
diff --git a/src/plugins/coreplugin/editormanager/documentmodel.cpp b/src/plugins/coreplugin/editormanager/documentmodel.cpp
index e0f2723ac3..512939911c 100644
--- a/src/plugins/coreplugin/editormanager/documentmodel.cpp
+++ b/src/plugins/coreplugin/editormanager/documentmodel.cpp
@@ -203,14 +203,14 @@ QIcon DocumentModelPrivate::pinnedIcon()
     return icon;
 }
 
-Utils::optional<int> DocumentModelPrivate::indexOfFilePath(const Utils::FilePath &filePath) const
+std::optional<int> DocumentModelPrivate::indexOfFilePath(const Utils::FilePath &filePath) const
 {
     if (filePath.isEmpty())
-        return Utils::nullopt;
+        return std::nullopt;
     const FilePath fixedPath = DocumentManager::filePathKey(filePath, DocumentManager::ResolveLinks);
     const int index = m_entries.indexOf(m_entryByFixedPath.value(fixedPath));
     if (index < 0)
-        return Utils::nullopt;
+        return std::nullopt;
     return index;
 }
 
@@ -233,13 +233,13 @@ void DocumentModelPrivate::removeDocument(int idx)
     delete entry;
 }
 
-Utils::optional<int> DocumentModelPrivate::indexOfDocument(IDocument *document) const
+std::optional<int> DocumentModelPrivate::indexOfDocument(IDocument *document) const
 {
     const int index = Utils::indexOf(m_entries, [&document](DocumentModel::Entry *entry) {
         return entry->document == document;
     });
     if (index < 0)
-        return Utils::nullopt;
+        return std::nullopt;
     return index;
 }
 
@@ -320,7 +320,7 @@ QVariant DocumentModelPrivate::data(const QModelIndex &index, int role) const
 
 void DocumentModelPrivate::itemChanged(IDocument *document)
 {
-    const Utils::optional<int> idx = indexOfDocument(document);
+    const std::optional<int> idx = indexOfDocument(document);
     if (!idx)
         return;
     const FilePath fixedPath = DocumentManager::filePathKey(document->filePath(),
@@ -582,12 +582,12 @@ QList<IEditor *> DocumentModel::editorsForDocuments(const QList<IDocument *> &do
     return result;
 }
 
-Utils::optional<int> DocumentModel::indexOfDocument(IDocument *document)
+std::optional<int> DocumentModel::indexOfDocument(IDocument *document)
 {
     return d->indexOfDocument(document);
 }
 
-Utils::optional<int> DocumentModel::indexOfFilePath(const Utils::FilePath &filePath)
+std::optional<int> DocumentModel::indexOfFilePath(const Utils::FilePath &filePath)
 {
     return d->indexOfFilePath(filePath);
 }
@@ -638,14 +638,14 @@ int DocumentModel::entryCount()
     return d->m_entries.count();
 }
 
-Utils::optional<int> DocumentModel::rowOfDocument(IDocument *document)
+std::optional<int> DocumentModel::rowOfDocument(IDocument *document)
 {
     if (!document)
         return 0 /*<no document>*/;
-    const Utils::optional<int> index = indexOfDocument(document);
+    const std::optional<int> index = indexOfDocument(document);
     if (index)
         return *index + 1/*correction for <no document>*/;
-    return Utils::nullopt;
+    return std::nullopt;
 }
 
 QList<DocumentModel::Entry *> DocumentModel::entries()
diff --git a/src/plugins/coreplugin/editormanager/documentmodel.h b/src/plugins/coreplugin/editormanager/documentmodel.h
index eb0c21f429..5918ab350a 100644
--- a/src/plugins/coreplugin/editormanager/documentmodel.h
+++ b/src/plugins/coreplugin/editormanager/documentmodel.h
@@ -7,7 +7,8 @@
 
 #include <utils/filepath.h>
 #include <utils/id.h>
-#include <utils/optional.h>
+
+#include <optional>
 
 QT_BEGIN_NAMESPACE
 class QAbstractItemModel;
@@ -52,12 +53,12 @@ public:
     };
 
     static Entry *entryAtRow(int row);
-    static Utils::optional<int> rowOfDocument(IDocument *document);
+    static std::optional<int> rowOfDocument(IDocument *document);
 
     static int entryCount();
     static QList<Entry *> entries();
-    static Utils::optional<int> indexOfDocument(IDocument *document);
-    static Utils::optional<int> indexOfFilePath(const Utils::FilePath &filePath);
+    static std::optional<int> indexOfDocument(IDocument *document);
+    static std::optional<int> indexOfFilePath(const Utils::FilePath &filePath);
     static Entry *entryForDocument(IDocument *document);
     static Entry *entryForFilePath(const Utils::FilePath &filePath);
     static QList<IDocument *> openedDocuments();
diff --git a/src/plugins/coreplugin/editormanager/documentmodel_p.h b/src/plugins/coreplugin/editormanager/documentmodel_p.h
index ae4c2f98e0..560dd0d0bd 100644
--- a/src/plugins/coreplugin/editormanager/documentmodel_p.h
+++ b/src/plugins/coreplugin/editormanager/documentmodel_p.h
@@ -36,8 +36,8 @@ public:
     void addEntry(DocumentModel::Entry *entry);
     void removeDocument(int idx);
 
-    Utils::optional<int> indexOfFilePath(const Utils::FilePath &filePath) const;
-    Utils::optional<int> indexOfDocument(IDocument *document) const;
+    std::optional<int> indexOfFilePath(const Utils::FilePath &filePath) const;
+    std::optional<int> indexOfDocument(IDocument *document) const;
 
     bool disambiguateDisplayNames(DocumentModel::Entry *entry);
 
diff --git a/src/plugins/coreplugin/editormanager/openeditorsview.cpp b/src/plugins/coreplugin/editormanager/openeditorsview.cpp
index 1a74a527d0..87e4174d2f 100644
--- a/src/plugins/coreplugin/editormanager/openeditorsview.cpp
+++ b/src/plugins/coreplugin/editormanager/openeditorsview.cpp
@@ -53,7 +53,7 @@ void OpenEditorsWidget::updateCurrentItem(IEditor *editor)
         clearSelection();
         return;
     }
-    const Utils::optional<int> index = DocumentModel::indexOfDocument(editor->document());
+    const std::optional<int> index = DocumentModel::indexOfDocument(editor->document());
     if (QTC_GUARD(index))
         setCurrentIndex(m_model->index(index.value(), 0));
     selectionModel()->select(currentIndex(),
diff --git a/src/plugins/coreplugin/editortoolbar.cpp b/src/plugins/coreplugin/editortoolbar.cpp
index 76f10ba15e..e7aaa2a51e 100644
--- a/src/plugins/coreplugin/editortoolbar.cpp
+++ b/src/plugins/coreplugin/editortoolbar.cpp
@@ -296,7 +296,7 @@ void EditorToolBar::setMenuProvider(const EditorToolBar::MenuProvider &provider)
 void EditorToolBar::setCurrentEditor(IEditor *editor)
 {
     IDocument *document = editor ? editor->document() : nullptr;
-    const Utils::optional<int> index = DocumentModel::rowOfDocument(document);
+    const std::optional<int> index = DocumentModel::rowOfDocument(document);
     if (QTC_GUARD(index))
         d->m_editorList->setCurrentIndex(*index);
 
diff --git a/src/plugins/coreplugin/externaltool.cpp b/src/plugins/coreplugin/externaltool.cpp
index 6c774b36af..d00d7e572b 100644
--- a/src/plugins/coreplugin/externaltool.cpp
+++ b/src/plugins/coreplugin/externaltool.cpp
@@ -159,7 +159,7 @@ Id ExternalTool::baseEnvironmentProviderId() const
 Environment ExternalTool::baseEnvironment() const
 {
     if (m_baseEnvironmentProviderId.isValid()) {
-        const optional<EnvironmentProvider> provider = EnvironmentProvider::provider(
+        const std::optional<EnvironmentProvider> provider = EnvironmentProvider::provider(
             m_baseEnvironmentProviderId.name());
         if (provider && provider->environment)
             return provider->environment();
diff --git a/src/plugins/coreplugin/find/searchresultitem.h b/src/plugins/coreplugin/find/searchresultitem.h
index 3c6400128d..fe6cedbacb 100644
--- a/src/plugins/coreplugin/find/searchresultitem.h
+++ b/src/plugins/coreplugin/find/searchresultitem.h
@@ -7,12 +7,13 @@
 
 #include <utils/filepath.h>
 #include <utils/hostosinfo.h>
-#include <utils/optional.h>
 
 #include <QIcon>
 #include <QStringList>
 #include <QVariant>
 
+#include <optional>
+
 namespace Core {
 
 namespace Search {
@@ -106,9 +107,9 @@ public:
     bool selectForReplacement() const { return m_selectForReplacement; }
     void setSelectForReplacement(bool select) { m_selectForReplacement = select; }
 
-    Utils::optional<QString> containingFunctionName() const { return m_containingFunctionName; }
+    std::optional<QString> containingFunctionName() const { return m_containingFunctionName; }
 
-    void setContainingFunctionName(Utils::optional<QString> containingFunctionName)
+    void setContainingFunctionName(std::optional<QString> containingFunctionName)
     {
         m_containingFunctionName = std::move(containingFunctionName);
     }
@@ -122,7 +123,7 @@ private:
     bool m_useTextEditorFont = false;
     bool m_selectForReplacement = true;
     SearchResultColor::Style m_style = SearchResultColor::Style::Default;
-    Utils::optional<QString> m_containingFunctionName;
+    std::optional<QString> m_containingFunctionName;
 };
 
 } // namespace Core
diff --git a/src/plugins/coreplugin/helpitem.h b/src/plugins/coreplugin/helpitem.h
index 79aa913324..8efab6467d 100644
--- a/src/plugins/coreplugin/helpitem.h
+++ b/src/plugins/coreplugin/helpitem.h
@@ -5,12 +5,11 @@
 
 #include "core_global.h"
 
-#include <utils/optional.h>
-
 #include <QString>
 #include <QUrl>
 #include <QVariant>
 
+#include <optional>
 #include <vector>
 
 namespace Core {
@@ -70,8 +69,8 @@ private:
     QStringList m_helpIds;
     QString m_docMark;
     Category m_category = Unknown;
-    mutable Utils::optional<Links> m_helpLinks; // cached help links
-    mutable Utils::optional<QString> m_firstParagraph;
+    mutable std::optional<Links> m_helpLinks; // cached help links
+    mutable std::optional<QString> m_firstParagraph;
     mutable QString m_keyword;
     mutable bool m_isFuzzyMatch = false;
 };
diff --git a/src/plugins/coreplugin/idocument.cpp b/src/plugins/coreplugin/idocument.cpp
index 1f828bfd24..8add39dfe0 100644
--- a/src/plugins/coreplugin/idocument.cpp
+++ b/src/plugins/coreplugin/idocument.cpp
@@ -6,13 +6,13 @@
 #include <utils/filepath.h>
 #include <utils/infobar.h>
 #include <utils/minimizableinfobars.h>
-#include <utils/optional.h>
 #include <utils/qtcassert.h>
 
 #include <QFile>
 #include <QFileInfo>
 
 #include <memory>
+#include <optional>
 
 /*!
     \class Core::IDocument
@@ -209,7 +209,7 @@ public:
     Utils::InfoBar *infoBar = nullptr;
     std::unique_ptr<MinimizableInfoBars> minimizableInfoBars;
     Id id;
-    optional<bool> fileIsReadOnly;
+    std::optional<bool> fileIsReadOnly;
     bool temporary = false;
     bool hasWriteWarning = false;
     bool restored = false;
diff --git a/src/plugins/coreplugin/locator/ilocatorfilter.h b/src/plugins/coreplugin/locator/ilocatorfilter.h
index 90564eed0b..993d49495b 100644
--- a/src/plugins/coreplugin/locator/ilocatorfilter.h
+++ b/src/plugins/coreplugin/locator/ilocatorfilter.h
@@ -7,13 +7,14 @@
 
 #include <utils/filepath.h>
 #include <utils/id.h>
-#include <utils/optional.h>
 
 #include <QFutureInterface>
 #include <QIcon>
 #include <QMetaType>
 #include <QVariant>
 
+#include <optional>
+
 namespace Core {
 
 class ILocatorFilter;
@@ -45,8 +46,10 @@ struct LocatorFilterEntry
 
     LocatorFilterEntry() = default;
 
-    LocatorFilterEntry(ILocatorFilter *fromFilter, const QString &name, const QVariant &data,
-                Utils::optional<QIcon> icon = Utils::nullopt)
+    LocatorFilterEntry(ILocatorFilter *fromFilter,
+                       const QString &name,
+                       const QVariant &data,
+                       std::optional<QIcon> icon = std::nullopt)
         : filter(fromFilter)
         , displayName(name)
         , internalData(data)
@@ -64,7 +67,7 @@ struct LocatorFilterEntry
     /* can be used by the filter to save more information about the entry */
     QVariant internalData;
     /* icon to display along with the entry */
-    Utils::optional<QIcon> displayIcon;
+    std::optional<QIcon> displayIcon;
     /* file path, if the entry is related to a file, is used e.g. for resolving a file icon */
     Utils::FilePath filePath;
     /* highlighting support */
diff --git a/src/plugins/coreplugin/locator/locatorwidget.h b/src/plugins/coreplugin/locator/locatorwidget.h
index 63b34f3405..ef6a25e8f6 100644
--- a/src/plugins/coreplugin/locator/locatorwidget.h
+++ b/src/plugins/coreplugin/locator/locatorwidget.h
@@ -6,13 +6,13 @@
 #include "locator.h"
 
 #include <extensionsystem/iplugin.h>
-#include <utils/optional.h>
 
 #include <QFutureWatcher>
 #include <QPointer>
 #include <QWidget>
 
 #include <functional>
+#include <optional>
 
 QT_BEGIN_NAMESPACE
 class QAbstractItemModel;
@@ -94,7 +94,7 @@ private:
     bool m_possibleToolTipRequest = false;
     QWidget *m_progressIndicator = nullptr;
     QTimer m_showProgressTimer;
-    Utils::optional<int> m_rowRequestedForAccept;
+    std::optional<int> m_rowRequestedForAccept;
     QPointer<QWidget> m_previousFocusWidget;
 };
 
diff --git a/src/plugins/coreplugin/loggingmanager.cpp b/src/plugins/coreplugin/loggingmanager.cpp
index 5f2fadfb9d..4a3f392d4c 100644
--- a/src/plugins/coreplugin/loggingmanager.cpp
+++ b/src/plugins/coreplugin/loggingmanager.cpp
@@ -75,9 +75,9 @@ static bool parseLine(const QString &line, FilterRuleSpec *filterRule)
     filterRule->category = categoryName;
 
     if (match.capturedLength(2) == 0)
-        filterRule->level = Utils::nullopt;
+        filterRule->level = std::nullopt;
     else
-        filterRule->level = Utils::make_optional(parseLevel(match.captured(2).mid(1)));
+        filterRule->level = std::make_optional(parseLevel(match.captured(2).mid(1)));
 
     const QString enabled = parts.at(1);
     if (enabled == "true" || enabled == "false") {
diff --git a/src/plugins/coreplugin/loggingmanager.h b/src/plugins/coreplugin/loggingmanager.h
index a323527476..9a2108051d 100644
--- a/src/plugins/coreplugin/loggingmanager.h
+++ b/src/plugins/coreplugin/loggingmanager.h
@@ -3,20 +3,20 @@
 
 #pragma once
 
-#include <utils/optional.h>
-
 #include <QColor>
 #include <QLoggingCategory>
 #include <QMap>
 #include <QObject>
 
+#include <optional>
+
 namespace Core {
 namespace Internal {
 
 struct FilterRuleSpec
 {
     QString category;
-    Utils::optional<QtMsgType> level;
+    std::optional<QtMsgType> level;
     bool enabled;
 };
 
diff --git a/src/plugins/coreplugin/systemsettings.cpp b/src/plugins/coreplugin/systemsettings.cpp
index 663f447063..bdb480ffc3 100644
--- a/src/plugins/coreplugin/systemsettings.cpp
+++ b/src/plugins/coreplugin/systemsettings.cpp
@@ -319,7 +319,7 @@ public:
         m_environmentChanges = CorePlugin::environmentChanges();
         updateEnvironmentChangesLabel();
         connect(environmentButton, &QPushButton::clicked, this, [this, environmentButton] {
-            Utils::optional<EnvironmentItems> changes
+            std::optional<EnvironmentItems> changes
                 = Utils::EnvironmentDialog::getEnvironmentItems(environmentButton,
                                                                 m_environmentChanges);
             if (!changes)
diff --git a/src/plugins/coreplugin/vcsmanager.cpp b/src/plugins/coreplugin/vcsmanager.cpp
index 0e944683c3..3e070950d9 100644
--- a/src/plugins/coreplugin/vcsmanager.cpp
+++ b/src/plugins/coreplugin/vcsmanager.cpp
@@ -15,7 +15,6 @@
 #include <utils/algorithm.h>
 #include <utils/fileutils.h>
 #include <utils/infobar.h>
-#include <utils/optional.h>
 #include <utils/qtcassert.h>
 #include <vcsbase/vcsbaseconstants.h>
 
@@ -27,6 +26,8 @@
 #include <QFileInfo>
 #include <QMessageBox>
 
+#include <optional>
+
 using namespace Utils;
 
 namespace Core {
@@ -57,14 +58,14 @@ public:
         QString topLevel;
     };
 
-    Utils::optional<VcsInfo> findInCache(const QString &dir) const
+    std::optional<VcsInfo> findInCache(const QString &dir) const
     {
-        QTC_ASSERT(QDir(dir).isAbsolute(), return Utils::nullopt);
-        QTC_ASSERT(!dir.endsWith(QLatin1Char('/')), return Utils::nullopt);
-        QTC_ASSERT(QDir::fromNativeSeparators(dir) == dir, return Utils::nullopt);
+        QTC_ASSERT(QDir(dir).isAbsolute(), return std::nullopt);
+        QTC_ASSERT(!dir.endsWith(QLatin1Char('/')), return std::nullopt);
+        QTC_ASSERT(QDir::fromNativeSeparators(dir) == dir, return std::nullopt);
 
         const auto it = m_cachedMatches.constFind(dir);
-        return it == m_cachedMatches.constEnd() ? Utils::nullopt : Utils::make_optional(it.value());
+        return it == m_cachedMatches.constEnd() ? std::nullopt : std::make_optional(it.value());
     }
 
     void clearCache()
diff --git a/src/plugins/coreplugin/welcomepagehelper.h b/src/plugins/coreplugin/welcomepagehelper.h
index 4a57b1f1a6..e6351e7273 100644
--- a/src/plugins/coreplugin/welcomepagehelper.h
+++ b/src/plugins/coreplugin/welcomepagehelper.h
@@ -6,14 +6,14 @@
 #include "core_global.h"
 #include "iwelcomepage.h"
 
-#include <utils/optional.h>
-
 #include <QElapsedTimer>
 #include <QPointer>
 #include <QSortFilterProxyModel>
 #include <QStyledItemDelegate>
 #include <QListView>
 
+#include <optional>
+
 namespace Utils { class FancyLineEdit; }
 
 namespace Core {
@@ -43,7 +43,7 @@ protected:
     void leaveEvent(QEvent *) final;
 };
 
-using OptModelIndex = Utils::optional<QModelIndex>;
+using OptModelIndex = std::optional<QModelIndex>;
 
 class CORE_EXPORT ListItem
 {
diff --git a/src/plugins/cppeditor/compileroptionsbuilder_test.cpp b/src/plugins/cppeditor/compileroptionsbuilder_test.cpp
index 523a3c9a2d..a2de9d9c81 100644
--- a/src/plugins/cppeditor/compileroptionsbuilder_test.cpp
+++ b/src/plugins/cppeditor/compileroptionsbuilder_test.cpp
@@ -81,7 +81,7 @@ public:
     QStringList extraFlags;
     bool isMsvc2015 = false;
 
-    Utils::optional<CompilerOptionsBuilder> compilerOptionsBuilder;
+    std::optional<CompilerOptionsBuilder> compilerOptionsBuilder;
 
 private:
     ProjectPart::ConstPtr projectPart;
diff --git a/src/plugins/cppeditor/cppcodemodelsettings.cpp b/src/plugins/cppeditor/cppcodemodelsettings.cpp
index cea4de6a7c..15280ef2a6 100644
--- a/src/plugins/cppeditor/cppcodemodelsettings.cpp
+++ b/src/plugins/cppeditor/cppcodemodelsettings.cpp
@@ -194,7 +194,7 @@ bool ClangdSettings::hardwareFulfillsRequirements()
     instance().m_data.haveCheckedHardwareReqirements = true;
     instance().saveSettings();
     const quint64 minRam = quint64(12) * 1024 * 1024 * 1024;
-    const Utils::optional<quint64> totalRam = Utils::HostOsInfo::totalMemoryInstalledInBytes();
+    const std::optional<quint64> totalRam = Utils::HostOsInfo::totalMemoryInstalledInBytes();
     return !totalRam || *totalRam >= minRam;
 }
 
diff --git a/src/plugins/cppeditor/cppcodestylesettings.cpp b/src/plugins/cppeditor/cppcodestylesettings.cpp
index 2fc9df0c11..31344ad52a 100644
--- a/src/plugins/cppeditor/cppcodestylesettings.cpp
+++ b/src/plugins/cppeditor/cppcodestylesettings.cpp
@@ -210,7 +210,7 @@ static void configureOverviewWithCodeStyleSettings(CPlusPlus::Overview &overview
 CPlusPlus::Overview CppCodeStyleSettings::currentProjectCodeStyleOverview()
 {
     CPlusPlus::Overview overview;
-    const Utils::optional<CppCodeStyleSettings> codeStyleSettings = currentProjectCodeStyle();
+    const std::optional<CppCodeStyleSettings> codeStyleSettings = currentProjectCodeStyle();
     configureOverviewWithCodeStyleSettings(overview,
                                            codeStyleSettings.value_or(currentGlobalCodeStyle()));
     return overview;
diff --git a/src/plugins/cppeditor/cppcodestylesettings.h b/src/plugins/cppeditor/cppcodestylesettings.h
index 9b36aeddb1..cf763ddde0 100644
--- a/src/plugins/cppeditor/cppcodestylesettings.h
+++ b/src/plugins/cppeditor/cppcodestylesettings.h
@@ -5,10 +5,10 @@
 
 #include "cppeditor_global.h"
 
-#include <utils/optional.h>
-
 #include <QVariantMap>
 
+#include <optional>
+
 namespace CPlusPlus { class Overview; }
 namespace TextEditor { class TabSettings; }
 namespace ProjectExplorer { class Project; }
diff --git a/src/plugins/cppeditor/cppquickfixes.cpp b/src/plugins/cppeditor/cppquickfixes.cpp
index 1bd8bda761..c2c91acec7 100644
--- a/src/plugins/cppeditor/cppquickfixes.cpp
+++ b/src/plugins/cppeditor/cppquickfixes.cpp
@@ -3346,7 +3346,7 @@ void InsertDefsFromDecls::match(const CppQuickFixInterface &interface, QuickFixO
 
 namespace {
 
-Utils::optional<FullySpecifiedType> getFirstTemplateParameter(const Name *name)
+std::optional<FullySpecifiedType> getFirstTemplateParameter(const Name *name)
 {
     if (const QualifiedNameId *qualifiedName = name->asQualifiedNameId())
         return getFirstTemplateParameter(qualifiedName->name());
@@ -3358,7 +3358,7 @@ Utils::optional<FullySpecifiedType> getFirstTemplateParameter(const Name *name)
     return {};
 }
 
-Utils::optional<FullySpecifiedType> getFirstTemplateParameter(Type *type)
+std::optional<FullySpecifiedType> getFirstTemplateParameter(Type *type)
 {
     if (NamedType *namedType = type->asNamedType())
         return getFirstTemplateParameter(namedType->name());
@@ -3366,7 +3366,7 @@ Utils::optional<FullySpecifiedType> getFirstTemplateParameter(Type *type)
     return {};
 }
 
-Utils::optional<FullySpecifiedType> getFirstTemplateParameter(FullySpecifiedType type)
+std::optional<FullySpecifiedType> getFirstTemplateParameter(FullySpecifiedType type)
 {
     return getFirstTemplateParameter(type.type());
 }
@@ -3870,7 +3870,7 @@ void GetterSetterRefactoringHelper::performGeneration(ExistingGetterSetterData d
     getSetTemplate.replacePlaceholders(data.memberVariableName, parameterName);
 
     using Pattern = CppQuickFixSettings::GetterSetterTemplate;
-    Utils::optional<FullySpecifiedType> returnTypeTemplateParameter;
+    std::optional<FullySpecifiedType> returnTypeTemplateParameter;
     if (getSetTemplate.returnTypeTemplate.has_value()) {
         QString returnTypeTemplate = getSetTemplate.returnTypeTemplate.value();
         if (returnTypeTemplate.contains(Pattern::TEMPLATE_PARAMETER_PATTERN)) {
diff --git a/src/plugins/cppeditor/cppquickfixsettings.h b/src/plugins/cppeditor/cppquickfixsettings.h
index 78032ab51d..0ac2ed91f8 100644
--- a/src/plugins/cppeditor/cppquickfixsettings.h
+++ b/src/plugins/cppeditor/cppquickfixsettings.h
@@ -3,11 +3,10 @@
 
 #pragma once
 
-#include <utils/optional.h>
-
 #include <QString>
 #include <QStringList>
 
+#include <optional>
 #include <vector>
 
 QT_BEGIN_NAMESPACE
@@ -48,7 +47,7 @@ public:
         QString assignment = "<cur> = <new>";
         const static inline QString TYPE_PATTERN = "<type>";
         const static inline QString TEMPLATE_PARAMETER_PATTERN = "<T>";
-        Utils::optional<QString> returnTypeTemplate;
+        std::optional<QString> returnTypeTemplate;
         void replacePlaceholders(QString currentValueVariableName, QString newValueVariableName);
     };
 
diff --git a/src/plugins/cppeditor/projectinfo_test.cpp b/src/plugins/cppeditor/projectinfo_test.cpp
index b2ea784135..de1807c1fd 100644
--- a/src/plugins/cppeditor/projectinfo_test.cpp
+++ b/src/plugins/cppeditor/projectinfo_test.cpp
@@ -513,7 +513,7 @@ public:
         user("/projectb/user_path"),
         user("/project/user_path")};
 
-    Utils::optional<HeaderPathFilter> filter;
+    std::optional<HeaderPathFilter> filter;
 
 private:
     ProjectPart::ConstPtr projectPart;
diff --git a/src/plugins/debugger/debuggerengine.h b/src/plugins/debugger/debuggerengine.h
index ad752a778e..0ed1bb3ef5 100644
--- a/src/plugins/debugger/debuggerengine.h
+++ b/src/plugins/debugger/debuggerengine.h
@@ -175,7 +175,7 @@ public:
 
     const Utils::MacroExpander *macroExpander = nullptr;
 
-    Utils::optional<int> exitCode = {};
+    std::optional<int> exitCode = {};
 
     // For Debugger testing.
     int testCase = 0;
diff --git a/src/plugins/debugger/peripheralregisterhandler.cpp b/src/plugins/debugger/peripheralregisterhandler.cpp
index f1ea47802a..4d9a8341d8 100644
--- a/src/plugins/debugger/peripheralregisterhandler.cpp
+++ b/src/plugins/debugger/peripheralregisterhandler.cpp
@@ -543,8 +543,8 @@ PeripheralRegisterHandler::PeripheralRegisterHandler(DebuggerEngine *engine)
 static void handleField(QXmlStreamReader &in, PeripheralRegister &reg)
 {
     PeripheralRegisterField fld;
-    Utils::optional<int> from;
-    Utils::optional<int> to;
+    std::optional<int> from;
+    std::optional<int> to;
     while (in.readNextStartElement()) {
         const auto elementName = in.name();
         if (elementName == QLatin1String(kName)) {
diff --git a/src/plugins/docker/dockerapi.cpp b/src/plugins/docker/dockerapi.cpp
index e9ef889107..6371757dac 100644
--- a/src/plugins/docker/dockerapi.cpp
+++ b/src/plugins/docker/dockerapi.cpp
@@ -62,7 +62,7 @@ void DockerApi::checkCanConnect(bool async)
         if (!lk.owns_lock())
             return;
 
-        m_dockerDaemonAvailable = nullopt;
+        m_dockerDaemonAvailable = std::nullopt;
         emit dockerDaemonAvailableChanged();
 
         auto future = Utils::runAsync([lk = std::move(lk), this] {
@@ -88,16 +88,16 @@ void DockerApi::recheckDockerDaemon()
     s_instance->checkCanConnect();
 }
 
-Utils::optional<bool> DockerApi::dockerDaemonAvailable(bool async)
+std::optional<bool> DockerApi::dockerDaemonAvailable(bool async)
 {
     if (!m_dockerDaemonAvailable.has_value())
         checkCanConnect(async);
     return m_dockerDaemonAvailable;
 }
 
-Utils::optional<bool> DockerApi::isDockerDaemonAvailable(bool async)
+std::optional<bool> DockerApi::isDockerDaemonAvailable(bool async)
 {
-    QTC_ASSERT(s_instance, return nullopt);
+    QTC_ASSERT(s_instance, return std::nullopt);
     return s_instance->dockerDaemonAvailable(async);
 }
 
diff --git a/src/plugins/docker/dockerapi.h b/src/plugins/docker/dockerapi.h
index 1834c995d4..990b06a76a 100644
--- a/src/plugins/docker/dockerapi.h
+++ b/src/plugins/docker/dockerapi.h
@@ -7,11 +7,12 @@
 
 #include <utils/filepath.h>
 #include <utils/guard.h>
-#include <utils/optional.h>
 
 #include <QMutex>
 #include <QObject>
 
+#include <optional>
+
 namespace Docker::Internal {
 
 class DockerApi : public QObject
@@ -31,13 +32,13 @@ signals:
     void dockerDaemonAvailableChanged();
 
 public:
-    Utils::optional<bool> dockerDaemonAvailable(bool async = true);
-    static Utils::optional<bool> isDockerDaemonAvailable(bool async = true);
+    std::optional<bool> dockerDaemonAvailable(bool async = true);
+    static std::optional<bool> isDockerDaemonAvailable(bool async = true);
 
 private:
     Utils::FilePath dockerClient();
 
-    Utils::optional<bool> m_dockerDaemonAvailable;
+    std::optional<bool> m_dockerDaemonAvailable;
     QMutex m_daemonCheckGuard;
     DockerSettings *m_settings;
 };
diff --git a/src/plugins/docker/dockerdevicewidget.cpp b/src/plugins/docker/dockerdevicewidget.cpp
index 48b96cfd0a..aab25aa362 100644
--- a/src/plugins/docker/dockerdevicewidget.cpp
+++ b/src/plugins/docker/dockerdevicewidget.cpp
@@ -194,7 +194,7 @@ DockerDeviceWidget::DockerDeviceWidget(const IDevice::Ptr &device)
 
 void DockerDeviceWidget::updateDaemonStateTexts()
 {
-    Utils::optional<bool> daemonState = DockerApi::instance()->dockerDaemonAvailable();
+    std::optional<bool> daemonState = DockerApi::instance()->dockerDaemonAvailable();
     if (!daemonState.has_value()) {
         m_daemonReset->setIcon(Icons::INFO.icon());
         m_daemonState->setText(Tr::tr("Daemon state not evaluated."));
diff --git a/src/plugins/docker/dockerplugin.h b/src/plugins/docker/dockerplugin.h
index 7c3d5bd2d5..bbe8776622 100644
--- a/src/plugins/docker/dockerplugin.h
+++ b/src/plugins/docker/dockerplugin.h
@@ -7,7 +7,7 @@
 
 #include <extensionsystem/iplugin.h>
 
-#include <utils/optional.h>
+#include <optional>
 
 namespace Docker::Internal {
 
diff --git a/src/plugins/fakevim/fakevimhandler.cpp b/src/plugins/fakevim/fakevimhandler.cpp
index 7374c7203a..fa52d2aba2 100644
--- a/src/plugins/fakevim/fakevimhandler.cpp
+++ b/src/plugins/fakevim/fakevimhandler.cpp
@@ -36,7 +36,6 @@
 #include "fakevimactions.h"
 #include "fakevimtr.h"
 
-#include <utils/optional.h>
 #include <utils/qtcprocess.h>
 
 #include <QDebug>
@@ -67,6 +66,7 @@
 #include <climits>
 #include <ctype.h>
 #include <functional>
+#include <optional>
 
 //#define DEBUG_KEY  1
 #if DEBUG_KEY
@@ -2400,7 +2400,7 @@ public:
 
         // If empty, cx{motion} will store the range defined by {motion} here.
         // If non-empty, cx{motion} replaces the {motion} with selectText(*exchangeData)
-        Utils::optional<Range> exchangeRange;
+        std::optional<Range> exchangeRange;
 
         bool surroundUpperCaseS; // True for yS and cS, false otherwise
         QString surroundFunction; // Used for storing the function name provided to ys{motion}f
diff --git a/src/plugins/fakevim/fakevimplugin.cpp b/src/plugins/fakevim/fakevimplugin.cpp
index cf9ae29401..58a1be54e7 100644
--- a/src/plugins/fakevim/fakevimplugin.cpp
+++ b/src/plugins/fakevim/fakevimplugin.cpp
@@ -2080,7 +2080,7 @@ int FakeVimPluginPrivate::currentFile() const
 {
     IEditor *editor = EditorManager::currentEditor();
     if (editor) {
-        const Utils::optional<int> index = DocumentModel::indexOfDocument(editor->document());
+        const std::optional<int> index = DocumentModel::indexOfDocument(editor->document());
         if (QTC_GUARD(index))
             return index.value();
     }
diff --git a/src/plugins/git/branchmodel.cpp b/src/plugins/git/branchmodel.cpp
index d81b2d2117..94983d7f87 100644
--- a/src/plugins/git/branchmodel.cpp
+++ b/src/plugins/git/branchmodel.cpp
@@ -726,17 +726,17 @@ void BranchModel::setOldBranchesIncluded(bool value)
     d->oldBranchesIncluded = value;
 }
 
-Utils::optional<QString> BranchModel::remoteName(const QModelIndex &idx) const
+std::optional<QString> BranchModel::remoteName(const QModelIndex &idx) const
 {
     const BranchNode *remotesNode = d->rootNode->children.at(RemoteBranches);
     const BranchNode *node = indexToNode(idx);
     if (!node)
-        return Utils::nullopt;
+        return std::nullopt;
     if (node == remotesNode)
         return QString();
     if (node->parent == remotesNode)
         return node->name;
-    return Utils::nullopt;
+    return std::nullopt;
 }
 
 void BranchModel::refreshCurrentBranch()
diff --git a/src/plugins/git/branchmodel.h b/src/plugins/git/branchmodel.h
index 015f57b9aa..4fa8794a7b 100644
--- a/src/plugins/git/branchmodel.h
+++ b/src/plugins/git/branchmodel.h
@@ -4,11 +4,12 @@
 #pragma once
 
 #include <utils/filepath.h>
-#include <utils/optional.h>
 
 #include <QAbstractListModel>
 #include <QVariant>
 
+#include <optional>
+
 namespace VcsBase { class VcsCommand; }
 
 namespace Git {
@@ -63,7 +64,7 @@ public:
     QModelIndex addBranch(const QString &name, bool track, const QModelIndex &trackedBranch);
     void setRemoteTracking(const QModelIndex &trackingIndex);
     void setOldBranchesIncluded(bool value);
-    Utils::optional<QString> remoteName(const QModelIndex &idx) const;
+    std::optional<QString> remoteName(const QModelIndex &idx) const;
     void refreshCurrentBranch();
 
 private:
diff --git a/src/plugins/git/branchview.cpp b/src/plugins/git/branchview.cpp
index 200d6106ab..6c03b91d53 100644
--- a/src/plugins/git/branchview.cpp
+++ b/src/plugins/git/branchview.cpp
@@ -228,7 +228,7 @@ void BranchView::slotCustomContextMenu(const QPoint &point)
 
     QMenu contextMenu;
     contextMenu.addAction(tr("&Add..."), this, &BranchView::add);
-    const Utils::optional<QString> remote = m_model->remoteName(index);
+    const std::optional<QString> remote = m_model->remoteName(index);
     if (remote.has_value()) {
         contextMenu.addAction(tr("&Fetch"), this, [this, &remote]() {
             GitClient::instance()->fetch(m_repository, *remote);
diff --git a/src/plugins/help/litehtmlhelpviewer.cpp b/src/plugins/help/litehtmlhelpviewer.cpp
index 7e50a957a1..0e8a993901 100644
--- a/src/plugins/help/litehtmlhelpviewer.cpp
+++ b/src/plugins/help/litehtmlhelpviewer.cpp
@@ -244,7 +244,7 @@ bool LiteHtmlHelpViewer::eventFilter(QObject *src, QEvent *e)
     return HelpViewer::eventFilter(src, e);
 }
 
-void LiteHtmlHelpViewer::setSourceInternal(const QUrl &url, Utils::optional<int> vscroll)
+void LiteHtmlHelpViewer::setSourceInternal(const QUrl &url, std::optional<int> vscroll)
 {
     slotLoadStarted();
     QUrl currentUrlWithoutFragment = m_viewer->url();
diff --git a/src/plugins/help/litehtmlhelpviewer.h b/src/plugins/help/litehtmlhelpviewer.h
index 3f8b231eda..5067f0a432 100644
--- a/src/plugins/help/litehtmlhelpviewer.h
+++ b/src/plugins/help/litehtmlhelpviewer.h
@@ -6,12 +6,12 @@
 #include "helpviewer.h"
 #include "openpagesmanager.h"
 
-#include <utils/optional.h>
-
 #include <qlitehtmlwidget.h>
 
 #include <QTextBrowser>
 
+#include <optional>
+
 namespace Help {
 namespace Internal {
 
@@ -54,7 +54,7 @@ public:
 private:
     void goForward(int count);
     void goBackward(int count);
-    void setSourceInternal(const QUrl &url, Utils::optional<int> vscroll = Utils::nullopt);
+    void setSourceInternal(const QUrl &url, std::optional<int> vscroll = std::nullopt);
     void showContextMenu(const QPoint &pos, const QUrl &url);
 
     struct HistoryItem
diff --git a/src/plugins/help/localhelpmanager.cpp b/src/plugins/help/localhelpmanager.cpp
index 7c9459149c..b395ebf2f7 100644
--- a/src/plugins/help/localhelpmanager.cpp
+++ b/src/plugins/help/localhelpmanager.cpp
@@ -27,7 +27,6 @@
 #include <utils/algorithm.h>
 #include <utils/environment.h>
 #include <utils/hostosinfo.h>
-#include <utils/optional.h>
 #include <utils/qtcassert.h>
 #include <utils/stringutils.h>
 
@@ -36,6 +35,8 @@
 #include <QHelpEngine>
 #include <QMutexLocker>
 
+#include <optional>
+
 using namespace Help::Internal;
 
 static LocalHelpManager *m_instance = nullptr;
@@ -279,7 +280,7 @@ void LocalHelpManager::setLastSelectedTab(int index)
     Core::ICore::settings()->setValueWithDefault(kLastSelectedTabKey, index, -1);
 }
 
-static Utils::optional<HelpViewerFactory> backendForId(const QByteArray &id)
+static std::optional<HelpViewerFactory> backendForId(const QByteArray &id)
 {
     const QVector<HelpViewerFactory> factories = LocalHelpManager::viewerBackends();
     const auto backend = std::find_if(std::begin(factories),
@@ -294,7 +295,7 @@ HelpViewerFactory LocalHelpManager::defaultViewerBackend()
 {
     const QString backend = Utils::qtcEnvironmentVariable("QTC_HELPVIEWER_BACKEND");
     if (!backend.isEmpty()) {
-        const Utils::optional<HelpViewerFactory> factory = backendForId(backend.toLatin1());
+        const std::optional<HelpViewerFactory> factory = backendForId(backend.toLatin1());
         if (factory)
             return *factory;
     }
diff --git a/src/plugins/languageclient/client.cpp b/src/plugins/languageclient/client.cpp
index 30f2567565..c86462bee4 100644
--- a/src/plugins/languageclient/client.cpp
+++ b/src/plugins/languageclient/client.cpp
@@ -511,7 +511,7 @@ void Client::initialize()
     initRequest.setResponseCallback([this](const InitializeRequest::Response &initResponse){
         d->initializeCallback(initResponse);
     });
-    if (Utils::optional<ResponseHandler> responseHandler = initRequest.responseHandler())
+    if (std::optional<ResponseHandler> responseHandler = initRequest.responseHandler())
         d->m_responseHandlers[responseHandler->id] = responseHandler->callback;
 
     // directly send content now otherwise the state check of sendContent would fail
@@ -590,7 +590,7 @@ void Client::openDocument(TextEditor::TextDocument *document)
     d->openRequiredShadowDocuments(document);
 
     const QString method(DidOpenTextDocumentNotification::methodName);
-    if (Utils::optional<bool> registered = d->m_dynamicCapabilities.isRegistered(method)) {
+    if (std::optional<bool> registered = d->m_dynamicCapabilities.isRegistered(method)) {
         if (!*registered)
             return;
         const TextDocumentRegistrationOptions option(
@@ -599,7 +599,7 @@ void Client::openDocument(TextEditor::TextDocument *document)
             && !option.filterApplies(filePath, Utils::mimeTypeForName(document->mimeType()))) {
             return;
         }
-    } else if (Utils::optional<ServerCapabilities::TextDocumentSync> _sync
+    } else if (std::optional<ServerCapabilities::TextDocumentSync> _sync
                = d->m_serverCapabilities.textDocumentSync()) {
         if (auto options = std::get_if<TextDocumentSyncOptions>(&*_sync)) {
             if (!options->openClose().value_or(true))
@@ -638,7 +638,7 @@ void Client::sendMessage(const JsonRpcMessage &message, SendDocUpdates sendUpdat
     QTC_ASSERT(d->m_state == Initialized, return);
     if (sendUpdates == SendDocUpdates::Send)
         d->sendPostponedDocumentUpdates(semanticTokensSchedule);
-    if (Utils::optional<ResponseHandler> responseHandler = message.responseHandler())
+    if (std::optional<ResponseHandler> responseHandler = message.responseHandler())
         d->m_responseHandlers[responseHandler->id] = responseHandler->callback;
     QString error;
     if (!QTC_GUARD(message.isValid(&error)))
@@ -774,7 +774,7 @@ void ClientPrivate::requestDocumentHighlightsNow(TextEditor::TextEditorWidget *w
         if (!option.filterApplies(widget->textDocument()->filePath()))
             return;
     } else {
-        Utils::optional<std::variant<bool, WorkDoneProgressOptions>> provider
+        std::optional<std::variant<bool, WorkDoneProgressOptions>> provider
             = m_serverCapabilities.documentHighlightProvider();
         if (!provider.has_value())
             return;
@@ -801,7 +801,7 @@ void ClientPrivate::requestDocumentHighlightsNow(TextEditor::TextEditorWidget *w
             disconnect(connection);
             const Id &id = TextEditor::TextEditorWidget::CodeSemanticsSelection;
             QList<QTextEdit::ExtraSelection> selections;
-            const Utils::optional<DocumentHighlightsResult> &result = response.result();
+            const std::optional<DocumentHighlightsResult> &result = response.result();
             if (!result.has_value() || std::holds_alternative<std::nullptr_t>(*result)) {
                 widget->setExtraSelections(id, selections);
                 return;
@@ -983,7 +983,7 @@ void Client::documentContentsSaved(TextEditor::TextDocument *document)
     bool send = true;
     bool includeText = false;
     const QString method(DidSaveTextDocumentNotification::methodName);
-    if (Utils::optional<bool> registered = d->m_dynamicCapabilities.isRegistered(method)) {
+    if (std::optional<bool> registered = d->m_dynamicCapabilities.isRegistered(method)) {
         send = *registered;
         if (send) {
             const TextDocumentSaveRegistrationOptions option(
@@ -994,10 +994,10 @@ void Client::documentContentsSaved(TextEditor::TextDocument *document)
                 includeText = option.includeText().value_or(includeText);
             }
         }
-    } else if (Utils::optional<ServerCapabilities::TextDocumentSync> _sync
+    } else if (std::optional<ServerCapabilities::TextDocumentSync> _sync
                = d->m_serverCapabilities.textDocumentSync()) {
         if (auto options = std::get_if<TextDocumentSyncOptions>(&*_sync)) {
-            if (Utils::optional<SaveOptions> saveOptions = options->save())
+            if (std::optional<SaveOptions> saveOptions = options->save())
                 includeText = saveOptions->includeText().value_or(includeText);
         }
     }
@@ -1019,7 +1019,7 @@ void Client::documentWillSave(Core::IDocument *document)
         return;
     bool send = false;
     const QString method(WillSaveTextDocumentNotification::methodName);
-    if (Utils::optional<bool> registered = d->m_dynamicCapabilities.isRegistered(method)) {
+    if (std::optional<bool> registered = d->m_dynamicCapabilities.isRegistered(method)) {
         send = *registered;
         if (send) {
             const TextDocumentRegistrationOptions option(d->m_dynamicCapabilities.option(method));
@@ -1028,7 +1028,7 @@ void Client::documentWillSave(Core::IDocument *document)
                                                    Utils::mimeTypeForName(document->mimeType()));
             }
         }
-    } else if (Utils::optional<ServerCapabilities::TextDocumentSync> _sync
+    } else if (std::optional<ServerCapabilities::TextDocumentSync> _sync
                = d->m_serverCapabilities.textDocumentSync()) {
         if (auto options = std::get_if<TextDocumentSyncOptions>(&*_sync))
             send = options->willSave().value_or(send);
@@ -1051,7 +1051,7 @@ void Client::documentContentsChanged(TextEditor::TextDocument *document,
         d->m_diagnosticManager->disableDiagnostics(document);
     const QString method(DidChangeTextDocumentNotification::methodName);
     TextDocumentSyncKind syncKind = d->m_serverCapabilities.textDocumentSyncKindHelper();
-    if (Utils::optional<bool> registered = d->m_dynamicCapabilities.isRegistered(method)) {
+    if (std::optional<bool> registered = d->m_dynamicCapabilities.isRegistered(method)) {
         syncKind = *registered ? TextDocumentSyncKind::Full : TextDocumentSyncKind::None;
         if (syncKind != TextDocumentSyncKind::None) {
             const TextDocumentChangeRegistrationOptions option(
@@ -1260,7 +1260,7 @@ void Client::requestCodeActions(const CodeActionRequest &request)
         = request.params().value_or(CodeActionParams()).textDocument().uri().toFilePath();
 
     const QString method(CodeActionRequest::methodName);
-    if (Utils::optional<bool> registered = d->m_dynamicCapabilities.isRegistered(method)) {
+    if (std::optional<bool> registered = d->m_dynamicCapabilities.isRegistered(method)) {
         if (!*registered)
             return;
         const TextDocumentRegistrationOptions option(
@@ -1280,9 +1280,9 @@ void Client::requestCodeActions(const CodeActionRequest &request)
 void Client::handleCodeActionResponse(const CodeActionRequest::Response &response,
                                           const DocumentUri &uri)
 {
-    if (const Utils::optional<CodeActionRequest::Response::Error> &error = response.error())
+    if (const std::optional<CodeActionRequest::Response::Error> &error = response.error())
         log(*error);
-    if (const Utils::optional<CodeActionResult> &result = response.result()) {
+    if (const std::optional<CodeActionResult> &result = response.result()) {
         if (auto list = std::get_if<QList<std::variant<Command, CodeAction>>>(&*result)) {
             QList<CodeAction> codeActions;
             for (const std::variant<Command, CodeAction> &item : *list) {
@@ -1489,7 +1489,7 @@ bool Client::supportsDocumentSymbols(const TextEditor::TextDocument *doc) const
         return !options.isValid()
                || options.filterApplies(doc->filePath(), Utils::mimeTypeForName(doc->mimeType()));
     }
-    const Utils::optional<std::variant<bool, WorkDoneProgressOptions>> &provider
+    const std::optional<std::variant<bool, WorkDoneProgressOptions>> &provider
         = capabilities().documentSymbolProvider();
     if (!provider.has_value())
         return false;
@@ -1644,7 +1644,7 @@ LanguageClientValue<MessageActionItem> ClientPrivate::showMessageBox(
     case Log: box->setIcon(QMessageBox::NoIcon); break;
     }
     QHash<QAbstractButton *, MessageActionItem> itemForButton;
-    if (const Utils::optional<QList<MessageActionItem>> actions = message.actions()) {
+    if (const std::optional<QList<MessageActionItem>> actions = message.actions()) {
         for (const MessageActionItem &action : *actions)
             itemForButton.insert(box->addButton(action.title(), QMessageBox::InvalidRole), action);
     }
@@ -1856,7 +1856,7 @@ void ClientPrivate::handleMethod(const QString &method, const MessageId &id, con
         m_tokenSupport.refresh();
         sendResponse(createDefaultResponse());
     } else if (method == ProgressNotification::methodName) {
-        if (Utils::optional<ProgressParams> params
+        if (std::optional<ProgressParams> params
             = ProgressNotification(message.toJsonObject()).params()) {
             if (!params->isValid())
                 q->log(invalidParamsErrorMessage(*params));
@@ -1917,8 +1917,8 @@ void Client::setDocumentChangeUpdateThreshold(int msecs)
 void ClientPrivate::initializeCallback(const InitializeRequest::Response &initResponse)
 {
     QTC_ASSERT(m_state == Client::InitializeRequested, return);
-    if (optional<ResponseError<InitializeError>> error = initResponse.error()) {
-        if (Utils::optional<InitializeError> data = error->data()) {
+    if (std::optional<ResponseError<InitializeError>> error = initResponse.error()) {
+        if (std::optional<InitializeError> data = error->data()) {
             if (data->retry()) {
                 const QString title(tr("Language Server \"%1\" Initialize Error").arg(m_displayName));
                 auto result = QMessageBox::warning(Core::ICore::dialogParent(),
@@ -1937,19 +1937,19 @@ void ClientPrivate::initializeCallback(const InitializeRequest::Response &initRe
         emit q->finished();
         return;
     }
-    if (const optional<InitializeResult> &result = initResponse.result()) {
+    if (const std::optional<InitializeResult> &result = initResponse.result()) {
         if (!result->isValid()) { // continue on ill formed result
             q->log(QJsonDocument(*result).toJson(QJsonDocument::Indented) + '\n'
                 + tr("Initialize result is invalid."));
         }
-        const Utils::optional<ServerInfo> serverInfo = result->serverInfo();
+        const std::optional<ServerInfo> serverInfo = result->serverInfo();
         if (serverInfo) {
             if (!serverInfo->isValid()) {
                 q->log(QJsonDocument(*result).toJson(QJsonDocument::Indented) + '\n'
                     + tr("Server Info is invalid."));
             } else {
                 m_serverName = serverInfo->name();
-                if (const Utils::optional<QString> version = serverInfo->version())
+                if (const std::optional<QString> version = serverInfo->version())
                     m_serverVersion = *version;
             }
         }
@@ -1981,7 +1981,7 @@ void ClientPrivate::initializeCallback(const InitializeRequest::Response &initRe
     qCDebug(LOGLSPCLIENT) << "language server " << m_displayName << " initialized";
     m_state = Client::Initialized;
     q->sendMessage(InitializeNotification(InitializedParams()));
-    Utils::optional<std::variant<bool, WorkDoneProgressOptions>> documentSymbolProvider
+    std::optional<std::variant<bool, WorkDoneProgressOptions>> documentSymbolProvider
         = q->capabilities().documentSymbolProvider();
     if (documentSymbolProvider.has_value()) {
         if (!std::holds_alternative<bool>(*documentSymbolProvider)
@@ -2005,7 +2005,7 @@ void ClientPrivate::shutDownCallback(const ShutdownRequest::Response &shutdownRe
     m_shutdownTimer.stop();
     QTC_ASSERT(m_state == Client::ShutdownRequested, return);
     QTC_ASSERT(m_clientInterface, return);
-    if (optional<ShutdownRequest::Response::Error> error = shutdownResponse.error())
+    if (std::optional<ShutdownRequest::Response::Error> error = shutdownResponse.error())
         q->log(*error);
     // directly send content now otherwise the state check of sendContent would fail
     sendMessageNow(ExitNotification());
diff --git a/src/plugins/languageclient/diagnosticmanager.cpp b/src/plugins/languageclient/diagnosticmanager.cpp
index 1cfedce9e7..8ec4cd117d 100644
--- a/src/plugins/languageclient/diagnosticmanager.cpp
+++ b/src/plugins/languageclient/diagnosticmanager.cpp
@@ -58,7 +58,7 @@ DiagnosticManager::~DiagnosticManager()
 
 void DiagnosticManager::setDiagnostics(const DocumentUri &uri,
                                        const QList<Diagnostic> &diagnostics,
-                                       const Utils::optional<int> &version)
+                                       const std::optional<int> &version)
 {
     hideDiagnostics(uri.toFilePath());
     m_diagnostics[uri] = {version, filteredDiagnostics(diagnostics)};
diff --git a/src/plugins/languageclient/diagnosticmanager.h b/src/plugins/languageclient/diagnosticmanager.h
index 64d9f74c1b..3898327619 100644
--- a/src/plugins/languageclient/diagnosticmanager.h
+++ b/src/plugins/languageclient/diagnosticmanager.h
@@ -32,7 +32,7 @@ public:
 
     virtual void setDiagnostics(const LanguageServerProtocol::DocumentUri &uri,
                                 const QList<LanguageServerProtocol::Diagnostic> &diagnostics,
-                                const Utils::optional<int> &version);
+                                const std::optional<int> &version);
 
     virtual void showDiagnostics(const LanguageServerProtocol::DocumentUri &uri, int version);
     virtual void hideDiagnostics(const Utils::FilePath &filePath);
@@ -68,7 +68,7 @@ protected:
 private:
     struct VersionedDiagnostics
     {
-        Utils::optional<int> version;
+        std::optional<int> version;
         QList<LanguageServerProtocol::Diagnostic> diagnostics;
     };
     QMap<LanguageServerProtocol::DocumentUri, VersionedDiagnostics> m_diagnostics;
diff --git a/src/plugins/languageclient/documentsymbolcache.cpp b/src/plugins/languageclient/documentsymbolcache.cpp
index 3f0abda89f..66c189a4b5 100644
--- a/src/plugins/languageclient/documentsymbolcache.cpp
+++ b/src/plugins/languageclient/documentsymbolcache.cpp
@@ -93,7 +93,7 @@ void DocumentSymbolCache::handleResponse(const DocumentUri &uri,
                                          const DocumentSymbolsRequest::Response &response)
 {
     m_runningRequests.remove(uri);
-    if (Utils::optional<DocumentSymbolsRequest::Response::Error> error = response.error()) {
+    if (std::optional<DocumentSymbolsRequest::Response::Error> error = response.error()) {
         if (m_client)
             m_client->log(*error);
     }
diff --git a/src/plugins/languageclient/documentsymbolcache.h b/src/plugins/languageclient/documentsymbolcache.h
index ce17ccf363..3403b91e70 100644
--- a/src/plugins/languageclient/documentsymbolcache.h
+++ b/src/plugins/languageclient/documentsymbolcache.h
@@ -6,8 +6,6 @@
 #include "languageclient_global.h"
 #include "languageclientutils.h"
 
-#include "utils/optional.h"
-
 #include <languageserverprotocol/languagefeatures.h>
 #include <languageserverprotocol/lsptypes.h>
 
@@ -16,6 +14,8 @@
 #include <QSet>
 #include <QTimer>
 
+#include <optional>
+
 namespace LanguageClient {
 
 class Client;
diff --git a/src/plugins/languageclient/dynamiccapabilities.cpp b/src/plugins/languageclient/dynamiccapabilities.cpp
index 239e4df2c1..152792bb46 100644
--- a/src/plugins/languageclient/dynamiccapabilities.cpp
+++ b/src/plugins/languageclient/dynamiccapabilities.cpp
@@ -27,10 +27,10 @@ void DynamicCapabilities::unregisterCapability(const QList<Unregistration> &unre
     }
 }
 
-Utils::optional<bool> DynamicCapabilities::isRegistered(const QString &method) const
+std::optional<bool> DynamicCapabilities::isRegistered(const QString &method) const
 {
     if (!m_capability.contains(method))
-        return Utils::nullopt;
+        return std::nullopt;
     return m_capability[method].enabled();
 }
 
diff --git a/src/plugins/languageclient/dynamiccapabilities.h b/src/plugins/languageclient/dynamiccapabilities.h
index 366df58547..47424d0edd 100644
--- a/src/plugins/languageclient/dynamiccapabilities.h
+++ b/src/plugins/languageclient/dynamiccapabilities.h
@@ -45,7 +45,7 @@ public:
     void registerCapability(const QList<LanguageServerProtocol::Registration> &registrations);
     void unregisterCapability(const QList<LanguageServerProtocol::Unregistration> &unregistrations);
 
-    Utils::optional<bool> isRegistered(const QString &method) const;
+    std::optional<bool> isRegistered(const QString &method) const;
     QJsonValue option(const QString &method) const { return m_capability.value(method).options(); }
     QStringList registeredMethods() const;
 
diff --git a/src/plugins/languageclient/languageclientcompletionassist.cpp b/src/plugins/languageclient/languageclientcompletionassist.cpp
index 674248545f..6c10870842 100644
--- a/src/plugins/languageclient/languageclientcompletionassist.cpp
+++ b/src/plugins/languageclient/languageclientcompletionassist.cpp
@@ -402,7 +402,7 @@ void LanguageClientCompletionAssistProcessor::handleCompletionResponse(
     if (auto error = response.error())
         m_client->log(*error);
 
-    const Utils::optional<CompletionResult> &result = response.result();
+    const std::optional<CompletionResult> &result = response.result();
     if (!result || std::holds_alternative<std::nullptr_t>(*result)) {
         setAsyncProposalAvailable(nullptr);
         m_client->removeAssistProcessor(this);
@@ -464,7 +464,7 @@ bool LanguageClientCompletionAssistProvider::isActivationCharSequence(const QStr
 }
 
 void LanguageClientCompletionAssistProvider::setTriggerCharacters(
-    const Utils::optional<QList<QString>> triggerChars)
+    const std::optional<QList<QString>> triggerChars)
 {
     m_activationCharSequenceLength = 0;
     m_triggerChars = triggerChars.value_or(QList<QString>());
diff --git a/src/plugins/languageclient/languageclientcompletionassist.h b/src/plugins/languageclient/languageclientcompletionassist.h
index 08634cb156..e78d1b795e 100644
--- a/src/plugins/languageclient/languageclientcompletionassist.h
+++ b/src/plugins/languageclient/languageclientcompletionassist.h
@@ -10,11 +10,10 @@
 #include <texteditor/codeassist/completionassistprovider.h>
 #include <texteditor/codeassist/iassistprocessor.h>
 
-#include <utils/optional.h>
-
 #include <QPointer>
 
 #include <functional>
+#include <optional>
 
 namespace TextEditor {
 class IAssistProposal;
@@ -40,7 +39,7 @@ public:
     bool isActivationCharSequence(const QString &sequence) const override;
     bool isContinuationChar(const QChar &) const override { return true; }
 
-    void setTriggerCharacters(const Utils::optional<QList<QString>> triggerChars);
+    void setTriggerCharacters(const std::optional<QList<QString>> triggerChars);
 
     void setSnippetsGroup(const QString &group) { m_snippetsGroup = group; }
 
@@ -78,7 +77,7 @@ private:
     QPointer<QTextDocument> m_document;
     Utils::FilePath m_filePath;
     QPointer<Client> m_client;
-    Utils::optional<LanguageServerProtocol::MessageId> m_currentRequest;
+    std::optional<LanguageServerProtocol::MessageId> m_currentRequest;
     QMetaObject::Connection m_postponedUpdateConnection;
     const QString m_snippetsGroup;
     int m_pos = -1;
diff --git a/src/plugins/languageclient/languageclientformatter.cpp b/src/plugins/languageclient/languageclientformatter.cpp
index f8800e72fe..774b0899de 100644
--- a/src/plugins/languageclient/languageclientformatter.cpp
+++ b/src/plugins/languageclient/languageclientformatter.cpp
@@ -55,7 +55,7 @@ QFutureWatcher<ChangeSet> *LanguageClientFormatter::format(
     const FilePath &filePath = m_document->filePath();
     const DynamicCapabilities dynamicCapabilities = m_client->dynamicCapabilities();
     const QString method(DocumentRangeFormattingRequest::methodName);
-    if (optional<bool> registered = dynamicCapabilities.isRegistered(method)) {
+    if (std::optional<bool> registered = dynamicCapabilities.isRegistered(method)) {
         if (!*registered)
             return nullptr;
         const TextDocumentRegistrationOptions option(dynamicCapabilities.option(method).toObject());
@@ -64,7 +64,7 @@ QFutureWatcher<ChangeSet> *LanguageClientFormatter::format(
             return nullptr;
         }
     } else {
-        const Utils::optional<std::variant<bool, WorkDoneProgressOptions>> &provider
+        const std::optional<std::variant<bool, WorkDoneProgressOptions>> &provider
             = m_client->capabilities().documentRangeFormattingProvider();
         if (!provider.has_value())
             return nullptr;
@@ -106,17 +106,18 @@ void LanguageClientFormatter::cancelCurrentRequest()
         m_progress.reportFinished();
         m_client->cancelRequest(*m_currentRequest);
         m_ignoreCancel = false;
-        m_currentRequest = nullopt;
+        m_currentRequest = std::nullopt;
     }
 }
 
 void LanguageClientFormatter::handleResponse(const DocumentRangeFormattingRequest::Response &response)
 {
-    m_currentRequest = nullopt;
-    if (const optional<DocumentRangeFormattingRequest::Response::Error> &error = response.error())
+    m_currentRequest = std::nullopt;
+    if (const std::optional<DocumentRangeFormattingRequest::Response::Error> &error = response
+                                                                                          .error())
         m_client->log(*error);
     ChangeSet changeSet;
-    if (optional<LanguageClientArray<TextEdit>> result = response.result()) {
+    if (std::optional<LanguageClientArray<TextEdit>> result = response.result()) {
         if (!result->isNull())
             changeSet = editsToChangeSet(result->toList(), m_document->document());
     }
diff --git a/src/plugins/languageclient/languageclientformatter.h b/src/plugins/languageclient/languageclientformatter.h
index f02d8efe18..e61e749d27 100644
--- a/src/plugins/languageclient/languageclientformatter.h
+++ b/src/plugins/languageclient/languageclientformatter.h
@@ -31,7 +31,7 @@ private:
     TextEditor::TextDocument *m_document; // not owned
     bool m_ignoreCancel = false;
     QFutureInterface<Utils::ChangeSet> m_progress;
-    Utils::optional<LanguageServerProtocol::MessageId> m_currentRequest;
+    std::optional<LanguageServerProtocol::MessageId> m_currentRequest;
 };
 
 } // namespace LanguageClient
diff --git a/src/plugins/languageclient/languageclientfunctionhint.cpp b/src/plugins/languageclient/languageclientfunctionhint.cpp
index 895c26e2e2..ec180f4f05 100644
--- a/src/plugins/languageclient/languageclientfunctionhint.cpp
+++ b/src/plugins/languageclient/languageclientfunctionhint.cpp
@@ -144,7 +144,7 @@ bool FunctionHintAssistProvider::isContinuationChar(const QChar &/*c*/) const
 }
 
 void FunctionHintAssistProvider::setTriggerCharacters(
-    const Utils::optional<QList<QString>> &triggerChars)
+    const std::optional<QList<QString>> &triggerChars)
 {
     m_triggerChars = triggerChars.value_or(QList<QString>());
     for (const QString &trigger : qAsConst(m_triggerChars)) {
diff --git a/src/plugins/languageclient/languageclientfunctionhint.h b/src/plugins/languageclient/languageclientfunctionhint.h
index 0103760646..d5f11409e9 100644
--- a/src/plugins/languageclient/languageclientfunctionhint.h
+++ b/src/plugins/languageclient/languageclientfunctionhint.h
@@ -8,10 +8,11 @@
 #include <languageserverprotocol/languagefeatures.h>
 #include <texteditor/codeassist/completionassistprovider.h>
 #include <texteditor/codeassist/iassistprocessor.h>
-#include <utils/optional.h>
 
 #include <QPointer>
 
+#include <optional>
+
 namespace TextEditor { class IAssistProposal; }
 
 namespace LanguageClient {
@@ -32,7 +33,7 @@ public:
     bool isActivationCharSequence(const QString &sequence) const override;
     bool isContinuationChar(const QChar &c) const override;
 
-    void setTriggerCharacters(const Utils::optional<QList<QString>> &triggerChars);
+    void setTriggerCharacters(const std::optional<QList<QString>> &triggerChars);
 
 private:
     QList<QString> m_triggerChars;
@@ -54,7 +55,7 @@ private:
         const LanguageServerProtocol::SignatureHelpRequest::Response &response);
 
     QPointer<Client> m_client;
-    Utils::optional<LanguageServerProtocol::MessageId> m_currentRequest;
+    std::optional<LanguageServerProtocol::MessageId> m_currentRequest;
     int m_pos = -1;
 };
 
diff --git a/src/plugins/languageclient/languageclienthoverhandler.cpp b/src/plugins/languageclient/languageclienthoverhandler.cpp
index dc0fbeb2c6..9204a1ec04 100644
--- a/src/plugins/languageclient/languageclienthoverhandler.cpp
+++ b/src/plugins/languageclient/languageclienthoverhandler.cpp
@@ -43,7 +43,7 @@ void HoverHandler::setHelpItem(const LanguageServerProtocol::MessageId &msgId,
                                const Core::HelpItem &help)
 {
     if (msgId == m_response.id()) {
-        if (Utils::optional<HoverResult> result = m_response.result()) {
+        if (std::optional<HoverResult> result = m_response.result()) {
             if (auto hover = std::get_if<Hover>(&(*result)))
                 setContent(hover->content());
         }
@@ -85,12 +85,12 @@ void HoverHandler::identifyMatch(TextEditor::TextEditorWidget *editorWidget,
     if (m_preferDiagnostics && reportDiagnostics(cursor))
         return;
 
-    const Utils::optional<std::variant<bool, WorkDoneProgressOptions>> &provider
+    const std::optional<std::variant<bool, WorkDoneProgressOptions>> &provider
         = m_client->capabilities().hoverProvider();
     bool sendMessage = provider.has_value();
     if (sendMessage && std::holds_alternative<bool>(*provider))
         sendMessage = std::get<bool>(*provider);
-    if (Utils::optional<bool> registered = m_client->dynamicCapabilities().isRegistered(
+    if (std::optional<bool> registered = m_client->dynamicCapabilities().isRegistered(
             HoverRequest::methodName)) {
         sendMessage = *registered;
         if (sendMessage) {
@@ -119,11 +119,11 @@ void HoverHandler::identifyMatch(TextEditor::TextEditorWidget *editorWidget,
 void HoverHandler::handleResponse(const HoverRequest::Response &response, const QTextCursor &cursor)
 {
     m_currentRequest.reset();
-    if (Utils::optional<HoverRequest::Response::Error> error = response.error()) {
+    if (std::optional<HoverRequest::Response::Error> error = response.error()) {
         if (m_client)
             m_client->log(*error);
     }
-    if (Utils::optional<HoverResult> result = response.result()) {
+    if (std::optional<HoverResult> result = response.result()) {
         if (auto hover = std::get_if<Hover>(&(*result))) {
             if (m_helpItemProvider) {
                 m_response = response;
diff --git a/src/plugins/languageclient/languageclienthoverhandler.h b/src/plugins/languageclient/languageclienthoverhandler.h
index 6bf0eba015..08840d406f 100644
--- a/src/plugins/languageclient/languageclienthoverhandler.h
+++ b/src/plugins/languageclient/languageclienthoverhandler.h
@@ -48,7 +48,7 @@ private:
     bool reportDiagnostics(const QTextCursor &cursor);
 
     QPointer<Client> m_client;
-    Utils::optional<LanguageServerProtocol::MessageId> m_currentRequest;
+    std::optional<LanguageServerProtocol::MessageId> m_currentRequest;
     LanguageServerProtocol::DocumentUri m_uri;
     LanguageServerProtocol::HoverRequest::Response m_response;
     TextEditor::BaseHoverHandler::ReportPriority m_report;
diff --git a/src/plugins/languageclient/languageclientquickfix.cpp b/src/plugins/languageclient/languageclientquickfix.cpp
index a675b1dc77..62c32ad94b 100644
--- a/src/plugins/languageclient/languageclientquickfix.cpp
+++ b/src/plugins/languageclient/languageclientquickfix.cpp
@@ -27,9 +27,9 @@ void CodeActionQuickFixOperation::perform()
 {
     if (!m_client)
         return;
-    if (Utils::optional<WorkspaceEdit> edit = m_action.edit())
+    if (std::optional<WorkspaceEdit> edit = m_action.edit())
         applyWorkspaceEdit(m_client, *edit);
-    else if (Utils::optional<Command> command = m_action.command())
+    else if (std::optional<Command> command = m_action.command())
         m_client->executeCommand(*command);
 }
 
@@ -91,11 +91,11 @@ void LanguageClientQuickFixAssistProcessor::cancel()
 void LanguageClientQuickFixAssistProcessor::handleCodeActionResponse(const CodeActionRequest::Response &response)
 {
     m_currentRequest.reset();
-    if (const Utils::optional<CodeActionRequest::Response::Error> &error = response.error())
+    if (const std::optional<CodeActionRequest::Response::Error> &error = response.error())
         m_client->log(*error);
     m_client->removeAssistProcessor(this);
     GenericProposal *proposal = nullptr;
-    if (const Utils::optional<CodeActionResult> &result = response.result())
+    if (const std::optional<CodeActionResult> &result = response.result())
         proposal = handleCodeActionResult(*result);
     setAsyncProposalAvailable(proposal);
 }
diff --git a/src/plugins/languageclient/languageclientquickfix.h b/src/plugins/languageclient/languageclientquickfix.h
index 7758472c58..6d2d9e5e26 100644
--- a/src/plugins/languageclient/languageclientquickfix.h
+++ b/src/plugins/languageclient/languageclientquickfix.h
@@ -79,7 +79,7 @@ private:
 
     QSharedPointer<const TextEditor::AssistInterface> m_assistInterface;
     Client *m_client = nullptr; // not owned
-    Utils::optional<LanguageServerProtocol::MessageId> m_currentRequest;
+    std::optional<LanguageServerProtocol::MessageId> m_currentRequest;
 };
 
 } // namespace LanguageClient
diff --git a/src/plugins/languageclient/languageclientsymbolsupport.cpp b/src/plugins/languageclient/languageclientsymbolsupport.cpp
index ede1dad1cf..a813e3c895 100644
--- a/src/plugins/languageclient/languageclientsymbolsupport.cpp
+++ b/src/plugins/languageclient/languageclientsymbolsupport.cpp
@@ -42,7 +42,7 @@ static void sendTextDocumentPositionParamsRequest(Client *client,
         else
             sendMessage = supportedFile;
     } else {
-        const Utils::optional<std::variant<bool, WorkDoneProgressOptions>> &provider
+        const std::optional<std::variant<bool, WorkDoneProgressOptions>> &provider
             = serverCapability.referencesProvider();
         sendMessage = provider.has_value();
         if (sendMessage && std::holds_alternative<bool>(*provider))
@@ -54,9 +54,9 @@ static void sendTextDocumentPositionParamsRequest(Client *client,
 
 static void handleGotoDefinitionResponse(const GotoDefinitionRequest::Response &response,
                                          Utils::LinkHandler callback,
-                                         Utils::optional<Utils::Link> linkUnderCursor)
+                                         std::optional<Utils::Link> linkUnderCursor)
 {
-    if (Utils::optional<GotoResult> result = response.result()) {
+    if (std::optional<GotoResult> result = response.result()) {
         if (std::holds_alternative<std::nullptr_t>(*result)) {
             callback({});
         } else if (auto ploc = std::get_if<Location>(&*result)) {
@@ -89,7 +89,7 @@ void SymbolSupport::findLinkAt(TextEditor::TextDocument *document,
     if (!m_client->reachable())
         return;
     GotoDefinitionRequest request(generateDocPosParams(document, cursor));
-    Utils::optional<Utils::Link> linkUnderCursor;
+    std::optional<Utils::Link> linkUnderCursor;
     if (!resolveTarget) {
         QTextCursor linkCursor = cursor;
         linkCursor.select(QTextCursor::WordUnderCursor);
@@ -196,7 +196,7 @@ void SymbolSupport::handleFindReferencesResponse(const FindReferencesRequest::Re
     }
 }
 
-Utils::optional<MessageId> SymbolSupport::findUsages(
+std::optional<MessageId> SymbolSupport::findUsages(
         TextEditor::TextDocument *document, const QTextCursor &cursor, const ResultHandler &handler)
 {
     if (!m_client->reachable())
@@ -278,11 +278,11 @@ void SymbolSupport::requestPrepareRename(const TextDocumentPositionParams &param
     PrepareRenameRequest request(params);
     request.setResponseCallback([this, params, placeholder](
                                     const PrepareRenameRequest::Response &response) {
-        const Utils::optional<PrepareRenameRequest::Response::Error> &error = response.error();
+        const std::optional<PrepareRenameRequest::Response::Error> &error = response.error();
         if (error.has_value())
             m_client->log(*error);
 
-        const Utils::optional<PrepareRenameResult> &result = response.result();
+        const std::optional<PrepareRenameResult> &result = response.result();
         if (result.has_value()) {
             if (std::holds_alternative<PlaceHolderResult>(*result)) {
                 auto placeHolderResult = std::get<PlaceHolderResult>(*result);
@@ -372,11 +372,11 @@ void SymbolSupport::startRenameSymbol(const TextDocumentPositionParams &position
 void SymbolSupport::handleRenameResponse(Core::SearchResult *search,
                                          const RenameRequest::Response &response)
 {
-    const Utils::optional<PrepareRenameRequest::Response::Error> &error = response.error();
+    const std::optional<PrepareRenameRequest::Response::Error> &error = response.error();
     if (error.has_value())
         m_client->log(*error);
 
-    const Utils::optional<WorkspaceEdit> &edits = response.result();
+    const std::optional<WorkspaceEdit> &edits = response.result();
     if (edits.has_value()) {
         search->addResults(generateReplaceItems(*edits), Core::SearchResult::AddOrdered);
         search->additionalReplaceWidget()->setVisible(false);
diff --git a/src/plugins/languageclient/languageclientsymbolsupport.h b/src/plugins/languageclient/languageclientsymbolsupport.h
index 2494871ca4..33b99fa32a 100644
--- a/src/plugins/languageclient/languageclientsymbolsupport.h
+++ b/src/plugins/languageclient/languageclientsymbolsupport.h
@@ -33,7 +33,7 @@ public:
                     const bool resolveTarget);
 
     using ResultHandler = std::function<void(const QList<LanguageServerProtocol::Location> &)>;
-    Utils::optional<LanguageServerProtocol::MessageId> findUsages(
+    std::optional<LanguageServerProtocol::MessageId> findUsages(
             TextEditor::TextDocument *document,
             const QTextCursor &cursor,
             const ResultHandler &handler = {});
diff --git a/src/plugins/languageclient/languageclientutils.cpp b/src/plugins/languageclient/languageclientutils.cpp
index 86d89e1fda..dbea480a70 100644
--- a/src/plugins/languageclient/languageclientutils.cpp
+++ b/src/plugins/languageclient/languageclientutils.cpp
@@ -170,17 +170,17 @@ void updateCodeActionRefactoringMarker(Client *client,
 
     for (const CodeAction &action : actions) {
         const QList<Diagnostic> &diagnostics = action.diagnostics().value_or(QList<Diagnostic>());
-        if (Utils::optional<WorkspaceEdit> edit = action.edit()) {
+        if (std::optional<WorkspaceEdit> edit = action.edit()) {
             if (diagnostics.isEmpty()) {
                 QList<TextEdit> edits;
-                if (optional<QList<TextDocumentEdit>> documentChanges = edit->documentChanges()) {
+                if (std::optional<QList<TextDocumentEdit>> documentChanges = edit->documentChanges()) {
                     QList<TextDocumentEdit> changesForUri = Utils::filtered(
                                 *documentChanges, [uri](const TextDocumentEdit &edit) {
                         return edit.textDocument().uri() == uri;
                     });
                     for (const TextDocumentEdit &edit : changesForUri)
                         edits << edit.edits();
-                } else if (optional<WorkspaceEdit::Changes> localChanges = edit->changes()) {
+                } else if (std::optional<WorkspaceEdit::Changes> localChanges = edit->changes()) {
                     edits = (*localChanges)[uri];
                 }
                 for (const TextEdit &edit : qAsConst(edits))
diff --git a/src/plugins/languageclient/locatorfilter.cpp b/src/plugins/languageclient/locatorfilter.cpp
index 43c22d695e..6df5170a42 100644
--- a/src/plugins/languageclient/locatorfilter.cpp
+++ b/src/plugins/languageclient/locatorfilter.cpp
@@ -83,7 +83,7 @@ static Core::LocatorFilterEntry generateLocatorEntry(const SymbolInformation &in
     Core::LocatorFilterEntry entry;
     entry.filter = filter;
     entry.displayName = info.name();
-    if (Utils::optional<QString> container = info.containerName())
+    if (std::optional<QString> container = info.containerName())
         entry.extraInfo = container.value_or(QString());
     entry.displayIcon = symbolIcon(info.kind());
     entry.internalData = QVariant::fromValue(info.location().toLink());
@@ -114,7 +114,7 @@ Core::LocatorFilterEntry DocumentLocatorFilter::generateLocatorEntry(
     Core::LocatorFilterEntry entry;
     entry.filter = this;
     entry.displayName = info.name();
-    if (Utils::optional<QString> detail = info.detail())
+    if (std::optional<QString> detail = info.detail())
         entry.extraInfo = detail.value_or(QString());
     entry.displayIcon = symbolIcon(info.kind());
     const Position &pos = info.range().start();
@@ -255,7 +255,7 @@ void WorkspaceLocatorFilter::prepareSearch(const QString &entry,
             continue;
         if (!(force || client->locatorsEnabled()))
             continue;
-        Utils::optional<std::variant<bool, WorkDoneProgressOptions>> capability
+        std::optional<std::variant<bool, WorkDoneProgressOptions>> capability
             = client->capabilities().workspaceSymbolProvider();
         if (!capability.has_value())
             continue;
diff --git a/src/plugins/languageclient/locatorfilter.h b/src/plugins/languageclient/locatorfilter.h
index 30381b39d4..afb8630795 100644
--- a/src/plugins/languageclient/locatorfilter.h
+++ b/src/plugins/languageclient/locatorfilter.h
@@ -66,7 +66,7 @@ private:
     QMutex m_mutex;
     QMetaObject::Connection m_updateSymbolsConnection;
     QMetaObject::Connection m_resetSymbolsConnection;
-    Utils::optional<LanguageServerProtocol::DocumentSymbolsResult> m_currentSymbols;
+    std::optional<LanguageServerProtocol::DocumentSymbolsResult> m_currentSymbols;
     bool m_forced = false;
 };
 
diff --git a/src/plugins/languageclient/lspinspector.h b/src/plugins/languageclient/lspinspector.h
index 4116764e4d..f515ef298c 100644
--- a/src/plugins/languageclient/lspinspector.h
+++ b/src/plugins/languageclient/lspinspector.h
@@ -31,8 +31,8 @@ public:
     QString displayText() const;
 
 private:
-    mutable Utils::optional<LanguageServerProtocol::MessageId> m_id;
-    mutable Utils::optional<QString> m_displayText;
+    mutable std::optional<LanguageServerProtocol::MessageId> m_id;
+    mutable std::optional<QString> m_displayText;
 };
 
 struct Capabilities
diff --git a/src/plugins/languageclient/progressmanager.cpp b/src/plugins/languageclient/progressmanager.cpp
index 8bb97afe7e..0f3580dcfb 100644
--- a/src/plugins/languageclient/progressmanager.cpp
+++ b/src/plugins/languageclient/progressmanager.cpp
@@ -77,7 +77,7 @@ void ProgressManager::reportProgress(const ProgressToken &token,
 {
     const LanguageClientProgress &progress = m_progress.value(token);
     if (progress.progressInterface) {
-        const Utils::optional<QString> &message = report.message();
+        const std::optional<QString> &message = report.message();
         if (message.has_value()) {
             progress.progressInterface->setSubtitle(*message);
             const bool showSubtitle = !message->isEmpty();
@@ -85,7 +85,7 @@ void ProgressManager::reportProgress(const ProgressToken &token,
         }
     }
     if (progress.futureInterface) {
-        if (const Utils::optional<double> &percentage = report.percentage(); percentage.has_value())
+        if (const std::optional<double> &percentage = report.percentage(); percentage.has_value())
             progress.futureInterface->setProgressValue(*percentage);
     }
 }
diff --git a/src/plugins/languageclient/semantichighlightsupport.cpp b/src/plugins/languageclient/semantichighlightsupport.cpp
index f700257477..e9f6429aca 100644
--- a/src/plugins/languageclient/semantichighlightsupport.cpp
+++ b/src/plugins/languageclient/semantichighlightsupport.cpp
@@ -323,7 +323,7 @@ SemanticRequestTypes SemanticTokenSupport::supportedSemanticRequests(TextDocumen
             return SemanticRequestType::None;
         return supportedRequests(dynamicCapabilities.option(dynamicMethod).toObject());
     }
-    if (Utils::optional<SemanticTokensOptions> provider = m_client->capabilities()
+    if (std::optional<SemanticTokensOptions> provider = m_client->capabilities()
                                                               .semanticTokensProvider()) {
         return supportedRequests(*provider);
     }
@@ -378,7 +378,7 @@ void SemanticTokenSupport::handleSemanticTokensDelta(
                 return;
             for (const auto start = data.begin() + edit.start(); it < start; ++it)
                 newData.append(*it);
-            if (const Utils::optional<QList<int>> editData = edit.data()) {
+            if (const std::optional<QList<int>> editData = edit.data()) {
                 newData.append(*editData);
                 qCDebug(LOGLSPHIGHLIGHT) << edit.start() << edit.deleteCount() << *editData;
             } else {
diff --git a/src/plugins/languageclient/snippet.cpp b/src/plugins/languageclient/snippet.cpp
index 37d5cb9ff8..6cda93d2f6 100644
--- a/src/plugins/languageclient/snippet.cpp
+++ b/src/plugins/languageclient/snippet.cpp
@@ -141,7 +141,7 @@ SnippetParseResult parseSnippet(const QString &snippet)
     ParsedSnippet result;
     ParsedSnippet::Part currentPart;
 
-    Utils::optional<QString> error;
+    std::optional<QString> error;
     auto it = snippet.begin();
     const auto end = snippet.end();
 
diff --git a/src/plugins/mesonprojectmanager/exewrappers/mesonwrapper.h b/src/plugins/mesonprojectmanager/exewrappers/mesonwrapper.h
index 023b118d86..72a7f13588 100644
--- a/src/plugins/mesonprojectmanager/exewrappers/mesonwrapper.h
+++ b/src/plugins/mesonprojectmanager/exewrappers/mesonwrapper.h
@@ -9,13 +9,13 @@
 #include <utils/environment.h>
 #include <utils/fileutils.h>
 #include <utils/id.h>
-#include <utils/optional.h>
 #include <utils/qtcprocess.h>
 
 #include <QFile>
 #include <QFileInfo>
 #include <QTemporaryFile>
 
+#include <optional>
 #include <tuple>
 
 namespace MesonProjectManager {
@@ -78,7 +78,7 @@ public:
 
     Command introspect(const Utils::FilePath &sourceDirectory) const;
 
-    static inline Utils::optional<Utils::FilePath> find()
+    static inline std::optional<Utils::FilePath> find()
     {
         return ToolWrapper::findTool({"meson.py", "meson"});
     }
diff --git a/src/plugins/mesonprojectmanager/exewrappers/ninjawrapper.h b/src/plugins/mesonprojectmanager/exewrappers/ninjawrapper.h
index 486068b29e..a67a436bf1 100644
--- a/src/plugins/mesonprojectmanager/exewrappers/ninjawrapper.h
+++ b/src/plugins/mesonprojectmanager/exewrappers/ninjawrapper.h
@@ -14,7 +14,7 @@ class NinjaWrapper final : public ToolWrapper
 public:
     using ToolWrapper::ToolWrapper;
 
-    static inline Utils::optional<Utils::FilePath> find()
+    static inline std::optional<Utils::FilePath> find()
     {
         return ToolWrapper::findTool({"ninja", "ninja-build"});
     }
diff --git a/src/plugins/mesonprojectmanager/exewrappers/toolwrapper.cpp b/src/plugins/mesonprojectmanager/exewrappers/toolwrapper.cpp
index 87102d28da..8e59b7d780 100644
--- a/src/plugins/mesonprojectmanager/exewrappers/toolwrapper.cpp
+++ b/src/plugins/mesonprojectmanager/exewrappers/toolwrapper.cpp
@@ -49,7 +49,7 @@ Version ToolWrapper::read_version(const Utils::FilePath &toolPath)
     return {};
 }
 
-Utils::optional<Utils::FilePath> ToolWrapper::findTool(const QStringList &exeNames)
+std::optional<Utils::FilePath> ToolWrapper::findTool(const QStringList &exeNames)
 {
     using namespace Utils;
     Environment systemEnvironment = Environment::systemEnvironment();
@@ -58,7 +58,7 @@ Utils::optional<Utils::FilePath> ToolWrapper::findTool(const QStringList &exeNam
         if (exe_path.exists())
             return exe_path;
     }
-    return Utils::nullopt;
+    return std::nullopt;
 }
 
 } // namespace Internal
diff --git a/src/plugins/mesonprojectmanager/exewrappers/toolwrapper.h b/src/plugins/mesonprojectmanager/exewrappers/toolwrapper.h
index 3f3e59c82a..2700b1fa81 100644
--- a/src/plugins/mesonprojectmanager/exewrappers/toolwrapper.h
+++ b/src/plugins/mesonprojectmanager/exewrappers/toolwrapper.h
@@ -16,6 +16,8 @@
 #include <QVariant>
 #include <QVariantMap>
 
+#include <optional>
+
 namespace MesonProjectManager {
 namespace Internal {
 
@@ -64,7 +66,7 @@ public:
 
     static Version read_version(const Utils::FilePath &toolPath);
 
-    static Utils::optional<Utils::FilePath> findTool(const QStringList &exeNames);
+    static std::optional<Utils::FilePath> findTool(const QStringList &exeNames);
 
     template<typename T>
     friend QVariantMap toVariantMap(const T &);
diff --git a/src/plugins/mesonprojectmanager/machinefiles/machinefilemanager.cpp b/src/plugins/mesonprojectmanager/machinefiles/machinefilemanager.cpp
index 67169f0812..0bfb482049 100644
--- a/src/plugins/mesonprojectmanager/machinefiles/machinefilemanager.cpp
+++ b/src/plugins/mesonprojectmanager/machinefiles/machinefilemanager.cpp
@@ -9,13 +9,14 @@
 
 #include <coreplugin/icore.h>
 
-#include <utils/optional.h>
 #include <utils/qtcassert.h>
 
 #include <QDir>
 #include <QFile>
 #include <QRegularExpression>
 
+#include <optional>
+
 namespace MesonProjectManager {
 namespace Internal {
 
diff --git a/src/plugins/mesonprojectmanager/mesoninfoparser/buildoptions.h b/src/plugins/mesonprojectmanager/mesoninfoparser/buildoptions.h
index bcc5cc220b..bde77dd723 100644
--- a/src/plugins/mesonprojectmanager/mesoninfoparser/buildoptions.h
+++ b/src/plugins/mesonprojectmanager/mesoninfoparser/buildoptions.h
@@ -4,7 +4,6 @@
 #pragma once
 
 #include <utils/fileutils.h>
-#include <utils/optional.h>
 
 #include <QCheckBox>
 #include <QComboBox>
@@ -13,6 +12,8 @@
 #include <QSpinBox>
 #include <QVariant>
 
+#include <optional>
+
 namespace MesonProjectManager {
 namespace Internal {
 
@@ -58,7 +59,7 @@ struct BuildOption
     const QString name;
     const QString section;
     const QString description;
-    const Utils::optional<QString> subproject;
+    const std::optional<QString> subproject;
     virtual ~BuildOption() {}
     virtual QVariant value() const = 0;
     virtual QString valueStr() const = 0;
@@ -79,8 +80,8 @@ struct BuildOption
         : name{name.contains(":") ? name.split(":").last() : name}
         , section{section}
         , description{description}
-        , subproject{name.contains(":") ? Utils::optional<QString>(name.split(":").first())
-                                        : Utils::nullopt}
+        , subproject{name.contains(":") ? std::optional<QString>(name.split(":").first())
+                                        : std::nullopt}
     {}
 }; // namespace Internal
 
diff --git a/src/plugins/mesonprojectmanager/mesoninfoparser/mesoninfoparser.h b/src/plugins/mesonprojectmanager/mesoninfoparser/mesoninfoparser.h
index 494a8acf2b..6833ea253e 100644
--- a/src/plugins/mesonprojectmanager/mesoninfoparser/mesoninfoparser.h
+++ b/src/plugins/mesonprojectmanager/mesoninfoparser/mesoninfoparser.h
@@ -12,7 +12,8 @@
 #include "target.h"
 
 #include <utils/fileutils.h>
-#include <utils/optional.h>
+
+#include <optional>
 
 namespace MesonProjectManager {
 namespace Internal {
@@ -26,7 +27,7 @@ struct Result
     TargetsList targets;
     BuildOptionsList buildOptions;
     std::vector<Utils::FilePath> buildSystemFiles;
-    Utils::optional<MesonInfo> mesonInfo;
+    std::optional<MesonInfo> mesonInfo;
 };
 
 inline Result parse(const QString &buildDir)
@@ -43,7 +44,7 @@ inline Result parse(const QByteArray &data)
     return {TargetParser{json}.targetList(),
             BuildOptionsParser{json}.takeBuildOptions(),
             BuildSystemFilesParser{json}.files(),
-            Utils::nullopt};
+            std::nullopt};
 }
 
 inline Result parse(QIODevice *introFile)
@@ -57,7 +58,7 @@ inline Result parse(QIODevice *introFile)
     }
     return {};
 }
-inline Utils::optional<MesonInfo> mesonInfo(const QString &buildDir)
+inline std::optional<MesonInfo> mesonInfo(const QString &buildDir)
 {
     return InfoParser{buildDir}.info();
 }
diff --git a/src/plugins/mesonprojectmanager/mesoninfoparser/parsers/buildsystemfilesparser.h b/src/plugins/mesonprojectmanager/mesoninfoparser/parsers/buildsystemfilesparser.h
index 0130906697..0856dac4ee 100644
--- a/src/plugins/mesonprojectmanager/mesoninfoparser/parsers/buildsystemfilesparser.h
+++ b/src/plugins/mesonprojectmanager/mesoninfoparser/parsers/buildsystemfilesparser.h
@@ -20,7 +20,7 @@ namespace Internal {
 class BuildSystemFilesParser
 {
     std::vector<Utils::FilePath> m_files;
-    static void appendFiles(const Utils::optional<QJsonArray> &arr, std::vector<Utils::FilePath> &dest)
+    static void appendFiles(const std::optional<QJsonArray> &arr, std::vector<Utils::FilePath> &dest)
     {
         if (arr)
             std::transform(std::cbegin(*arr),
diff --git a/src/plugins/mesonprojectmanager/mesoninfoparser/parsers/common.h b/src/plugins/mesonprojectmanager/mesoninfoparser/parsers/common.h
index 67d79e0c85..7537acaa60 100644
--- a/src/plugins/mesonprojectmanager/mesoninfoparser/parsers/common.h
+++ b/src/plugins/mesonprojectmanager/mesoninfoparser/parsers/common.h
@@ -3,14 +3,14 @@
 
 #pragma once
 
-#include <utils/optional.h>
-
 #include <QFile>
 #include <QJsonArray>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QJsonValue>
 
+#include <optional>
+
 namespace MesonProjectManager {
 namespace Internal {
 
@@ -45,7 +45,7 @@ inline QJsonObject load<QJsonObject>(const QJsonValueRef &ref)
 }
 
 template<typename T>
-inline Utils::optional<T> load(const QString &jsonFile)
+inline std::optional<T> load(const QString &jsonFile)
 {
     QFile js(jsonFile);
     js.open(QIODevice::ReadOnly | QIODevice::Text);
@@ -53,40 +53,40 @@ inline Utils::optional<T> load(const QString &jsonFile)
         auto data = js.readAll();
         return load<T>(QJsonDocument::fromJson(data));
     }
-    return Utils::nullopt;
+    return std::nullopt;
 }
 
 template<typename T>
-inline Utils::optional<T> get(const QJsonObject &obj, const QString &name);
+inline std::optional<T> get(const QJsonObject &obj, const QString &name);
 
 template<>
-inline Utils::optional<QJsonArray> get<QJsonArray>(const QJsonObject &obj, const QString &name)
+inline std::optional<QJsonArray> get<QJsonArray>(const QJsonObject &obj, const QString &name)
 {
     if (obj.contains(name)) {
         auto child = obj[name];
         if (child.isArray())
             return child.toArray();
     }
-    return Utils::nullopt;
+    return std::nullopt;
 }
 
 template<>
-inline Utils::optional<QJsonObject> get<QJsonObject>(const QJsonObject &obj, const QString &name)
+inline std::optional<QJsonObject> get<QJsonObject>(const QJsonObject &obj, const QString &name)
 {
     if (obj.contains(name)) {
         auto child = obj[name];
         if (child.isObject())
             return child.toObject();
     }
-    return Utils::nullopt;
+    return std::nullopt;
 }
 
 template<typename T, typename... Strings>
-inline Utils::optional<T> get(const QJsonObject &obj, const QString &firstPath, const Strings &...path)
+inline std::optional<T> get(const QJsonObject &obj, const QString &firstPath, const Strings &...path)
 {
     if (obj.contains(firstPath))
         return get<T>(obj[firstPath].toObject(), path...);
-    return Utils::nullopt;
+    return std::nullopt;
 }
 
 } // namespace Internal
diff --git a/src/plugins/mesonprojectmanager/mesoninfoparser/target.h b/src/plugins/mesonprojectmanager/mesoninfoparser/target.h
index e55d7b5d35..8b5b5a4b8c 100644
--- a/src/plugins/mesonprojectmanager/mesoninfoparser/target.h
+++ b/src/plugins/mesonprojectmanager/mesoninfoparser/target.h
@@ -5,11 +5,12 @@
 
 #include <utils/algorithm.h>
 #include <utils/fileutils.h>
-#include <utils/optional.h>
 
 #include <QDir>
 #include <QVariant>
 
+#include <optional>
+
 namespace MesonProjectManager {
 namespace Internal {
 
@@ -56,7 +57,7 @@ struct Target
     const QString definedIn;
     const QStringList fileName;
     const QStringList extraFiles;
-    const Utils::optional<QString> subproject;
+    const std::optional<QString> subproject;
     const SourceGroupList sources;
 
     static inline QString fullName(const Utils::FilePath &srcDir, const Target &target)
@@ -104,8 +105,8 @@ struct Target
         , definedIn{QDir::cleanPath(definedIn)}
         , fileName{cleanPath(std::move(fileName))}
         , extraFiles{cleanPath(std::move(extraFiles))}
-        , subproject{subproject.isNull() ? Utils::nullopt
-                                         : Utils::optional<QString>{std::move(subproject)}}
+        , subproject{subproject.isNull() ? std::nullopt
+                                         : std::optional<QString>{std::move(subproject)}}
         , sources{std::move(sources)}
     {}
 };
diff --git a/src/plugins/mesonprojectmanager/project/buildoptions/optionsmodel/buildoptionsmodel.h b/src/plugins/mesonprojectmanager/project/buildoptions/optionsmodel/buildoptionsmodel.h
index 8ee9fe1fef..895a346ff4 100644
--- a/src/plugins/mesonprojectmanager/project/buildoptions/optionsmodel/buildoptionsmodel.h
+++ b/src/plugins/mesonprojectmanager/project/buildoptions/optionsmodel/buildoptionsmodel.h
@@ -49,7 +49,7 @@ public:
     inline const QString &name() const { return m_currentValue->name; }
     inline const QString &section() const { return m_currentValue->section; }
     inline const QString &description() const { return m_currentValue->description; }
-    inline const Utils::optional<QString> &subproject() const
+    inline const std::optional<QString> &subproject() const
     {
         return m_currentValue->subproject;
     };
diff --git a/src/plugins/mesonprojectmanager/project/mesonprojectparser.cpp b/src/plugins/mesonprojectmanager/project/mesonprojectparser.cpp
index dae9b03355..28073d3478 100644
--- a/src/plugins/mesonprojectmanager/project/mesonprojectparser.cpp
+++ b/src/plugins/mesonprojectmanager/project/mesonprojectparser.cpp
@@ -13,12 +13,13 @@
 #include <projectexplorer/projectexplorer.h>
 
 #include <utils/fileinprojectfinder.h>
-#include <utils/optional.h>
 #include <utils/runextensions.h>
 
 #include <QStringList>
 #include <QTextStream>
 
+#include <optional>
+
 namespace MesonProjectManager {
 namespace Internal {
 
@@ -29,21 +30,21 @@ struct CompilerArgs
     ProjectExplorer::Macros macros;
 };
 
-inline Utils::optional<QString> extractValueIfMatches(const QString &arg,
+inline std::optional<QString> extractValueIfMatches(const QString &arg,
                                                       const QStringList &candidates)
 {
     for (const auto &flag : candidates) {
         if (arg.startsWith(flag))
             return arg.mid(flag.length());
     }
-    return Utils::nullopt;
+    return std::nullopt;
 }
 
-inline Utils::optional<QString> extractInclude(const QString &arg)
+inline std::optional<QString> extractInclude(const QString &arg)
 {
     return extractValueIfMatches(arg, {"-I", "/I", "-isystem", "-imsvc", "/imsvc"});
 }
-inline Utils::optional<ProjectExplorer::Macro> extractMacro(const QString &arg)
+inline std::optional<ProjectExplorer::Macro> extractMacro(const QString &arg)
 {
     auto define = extractValueIfMatches(arg, {"-D", "/D"});
     if (define)
@@ -51,7 +52,7 @@ inline Utils::optional<ProjectExplorer::Macro> extractMacro(const QString &arg)
     auto undef = extractValueIfMatches(arg, {"-U", "/U"});
     if (undef)
         return ProjectExplorer::Macro(undef->toLatin1(), ProjectExplorer::MacroType::Undefine);
-    return Utils::nullopt;
+    return std::nullopt;
 }
 
 CompilerArgs splitArgs(const QStringList &args)
diff --git a/src/plugins/mesonprojectmanager/project/outputparsers/ninjaparser.cpp b/src/plugins/mesonprojectmanager/project/outputparsers/ninjaparser.cpp
index 61ebb101d4..763459f538 100644
--- a/src/plugins/mesonprojectmanager/project/outputparsers/ninjaparser.cpp
+++ b/src/plugins/mesonprojectmanager/project/outputparsers/ninjaparser.cpp
@@ -10,7 +10,7 @@ namespace Internal {
 
 NinjaParser::NinjaParser() {}
 
-Utils::optional<int> NinjaParser::extractProgress(const QString &line)
+std::optional<int> NinjaParser::extractProgress(const QString &line)
 {
     auto progress = m_progressRegex.match(line);
     if (progress.hasMatch()) {
@@ -18,7 +18,7 @@ Utils::optional<int> NinjaParser::extractProgress(const QString &line)
         auto pos = progress.captured(1).toInt();
         return pos * 100 / total;
     }
-    return Utils::nullopt;
+    return std::nullopt;
 }
 
 void NinjaParser::setSourceDirectory(const Utils::FilePath &sourceDir)
diff --git a/src/plugins/mesonprojectmanager/project/outputparsers/ninjaparser.h b/src/plugins/mesonprojectmanager/project/outputparsers/ninjaparser.h
index 6acd265ba6..b77e130526 100644
--- a/src/plugins/mesonprojectmanager/project/outputparsers/ninjaparser.h
+++ b/src/plugins/mesonprojectmanager/project/outputparsers/ninjaparser.h
@@ -6,10 +6,10 @@
 #include <projectexplorer/ioutputparser.h>
 #include <projectexplorer/task.h>
 
-#include <utils/optional.h>
-
 #include <QRegularExpression>
 
+#include <optional>
+
 namespace MesonProjectManager {
 namespace Internal {
 
@@ -17,7 +17,7 @@ class NinjaParser final : public ProjectExplorer::OutputTaskParser
 {
     Q_OBJECT
     QRegularExpression m_progressRegex{R"(^\[(\d+)/(\d+)\])"};
-    Utils::optional<int> extractProgress(const QString &line);
+    std::optional<int> extractProgress(const QString &line);
 
 public:
     NinjaParser();
diff --git a/src/plugins/mesonprojectmanager/project/projecttree/mesonprojectnodes.h b/src/plugins/mesonprojectmanager/project/projecttree/mesonprojectnodes.h
index 80e4064f8f..d248807a80 100644
--- a/src/plugins/mesonprojectmanager/project/projecttree/mesonprojectnodes.h
+++ b/src/plugins/mesonprojectmanager/project/projecttree/mesonprojectnodes.h
@@ -34,7 +34,7 @@ class MesonFileNode : public ProjectExplorer::ProjectNode
 public:
     MesonFileNode(const Utils::FilePath &file);
     bool showInSimpleTree() const final { return false; }
-    Utils::optional<Utils::FilePath> visibleAfterAddFileAction() const override
+    std::optional<Utils::FilePath> visibleAfterAddFileAction() const override
     {
         return filePath().pathAppended("meson.build");
     }
diff --git a/src/plugins/mesonprojectmanager/settings/tools/toolitemsettings.cpp b/src/plugins/mesonprojectmanager/settings/tools/toolitemsettings.cpp
index cac4180a3c..5492183a07 100644
--- a/src/plugins/mesonprojectmanager/settings/tools/toolitemsettings.cpp
+++ b/src/plugins/mesonprojectmanager/settings/tools/toolitemsettings.cpp
@@ -31,14 +31,14 @@ ToolItemSettings::~ToolItemSettings()
 void ToolItemSettings::load(ToolTreeItem *item)
 {
     if (item) {
-        m_currentId = Utils::nullopt;
+        m_currentId = std::nullopt;
         ui->mesonNameLineEdit->setDisabled(item->isAutoDetected());
         ui->mesonNameLineEdit->setText(item->name());
         ui->mesonPathChooser->setDisabled(item->isAutoDetected());
         ui->mesonPathChooser->setFilePath(item->executable());
         m_currentId = item->id();
     } else {
-        m_currentId = Utils::nullopt;
+        m_currentId = std::nullopt;
     }
 }
 
diff --git a/src/plugins/mesonprojectmanager/settings/tools/toolitemsettings.h b/src/plugins/mesonprojectmanager/settings/tools/toolitemsettings.h
index faae7c1185..3d1407622f 100644
--- a/src/plugins/mesonprojectmanager/settings/tools/toolitemsettings.h
+++ b/src/plugins/mesonprojectmanager/settings/tools/toolitemsettings.h
@@ -5,10 +5,11 @@
 
 #include <utils/id.h>
 #include <utils/fileutils.h>
-#include <utils/optional.h>
 
 #include <QWidget>
 
+#include <optional>
+
 namespace MesonProjectManager {
 namespace Internal {
 
@@ -29,7 +30,7 @@ public:
 
 private:
     Ui::ToolItemSettings *ui;
-    Utils::optional<Utils::Id> m_currentId{Utils::nullopt};
+    std::optional<Utils::Id> m_currentId{std::nullopt};
 };
 
 } // namespace Internal
diff --git a/src/plugins/mesonprojectmanager/settings/tools/tooltreeitem.h b/src/plugins/mesonprojectmanager/settings/tools/tooltreeitem.h
index 4420f57571..8c02132510 100644
--- a/src/plugins/mesonprojectmanager/settings/tools/tooltreeitem.h
+++ b/src/plugins/mesonprojectmanager/settings/tools/tooltreeitem.h
@@ -8,12 +8,13 @@
 
 #include <utils/fileutils.h>
 #include <utils/id.h>
-#include <utils/optional.h>
 #include <utils/treemodel.h>
 
 #include <QCoreApplication>
 #include <QString>
 
+#include <optional>
+
 namespace MesonProjectManager {
 namespace Internal {
 
diff --git a/src/plugins/projectexplorer/buildstep.h b/src/plugins/projectexplorer/buildstep.h
index 2aa7c4d336..79ae4a60bc 100644
--- a/src/plugins/projectexplorer/buildstep.h
+++ b/src/plugins/projectexplorer/buildstep.h
@@ -8,7 +8,6 @@
 #include "buildconfiguration.h"
 #include "projectexplorer_export.h"
 
-#include <utils/optional.h>
 #include <utils/qtcassert.h>
 
 #include <QWidget>
@@ -16,6 +15,7 @@
 #include <atomic>
 #include <functional>
 #include <memory>
+#include <optional>
 
 namespace Utils {
 class Environment;
@@ -134,7 +134,7 @@ private:
     bool m_widgetExpandedByDefault = true;
     bool m_runInGuiThread = true;
     bool m_addMacroExpander = false;
-    Utils::optional<bool> m_wasExpanded;
+    std::optional<bool> m_wasExpanded;
     std::function<QString()> m_summaryUpdater;
 
     QString m_summaryText;
diff --git a/src/plugins/projectexplorer/gcctoolchain.cpp b/src/plugins/projectexplorer/gcctoolchain.cpp
index 9275072256..3461b7e7c4 100644
--- a/src/plugins/projectexplorer/gcctoolchain.cpp
+++ b/src/plugins/projectexplorer/gcctoolchain.cpp
@@ -469,7 +469,7 @@ ToolChain::MacroInspectionRunner GccToolChain::createMacroInspectionRunner() con
         QStringList allFlags = platformCodeGenFlags + flags;  // add only cxxflags is empty?
         QStringList arguments = gccPredefinedMacrosOptions(lang) + filteredFlags(allFlags, true);
         arguments = reinterpretOptions(arguments);
-        const Utils::optional<MacroInspectionReport> cachedMacros = macroCache->check(arguments);
+        const std::optional<MacroInspectionReport> cachedMacros = macroCache->check(arguments);
         if (cachedMacros)
             return cachedMacros.value();
 
@@ -616,7 +616,7 @@ HeaderPaths GccToolChain::builtInHeaderPaths(const Utils::Environment &env,
     if (!originalTargetTriple.isEmpty())
         arguments << "-target" << originalTargetTriple;
 
-    const Utils::optional<HeaderPaths> cachedPaths = headerCache->check(qMakePair(env, arguments));
+    const std::optional<HeaderPaths> cachedPaths = headerCache->check(qMakePair(env, arguments));
     if (cachedPaths)
         return cachedPaths.value();
 
diff --git a/src/plugins/projectexplorer/gcctoolchain.h b/src/plugins/projectexplorer/gcctoolchain.h
index 71df6ac75d..e17c79d3ec 100644
--- a/src/plugins/projectexplorer/gcctoolchain.h
+++ b/src/plugins/projectexplorer/gcctoolchain.h
@@ -11,10 +11,10 @@
 #include "headerpath.h"
 
 #include <utils/fileutils.h>
-#include <utils/optional.h>
 
 #include <functional>
 #include <memory>
+#include <optional>
 
 namespace ProjectExplorer {
 
@@ -222,7 +222,7 @@ protected:
 private:
     // "resolved" on macOS from /usr/bin/clang(++) etc to <DeveloperDir>/usr/bin/clang(++)
     // which is used for comparison with matchesCompileCommand
-    mutable Utils::optional<Utils::FilePath> m_resolvedCompilerCommand;
+    mutable std::optional<Utils::FilePath> m_resolvedCompilerCommand;
     QByteArray m_parentToolChainId;
     QMetaObject::Connection m_mingwToolchainAddedConnection;
     QMetaObject::Connection m_thisToolchainRemovedConnection;
diff --git a/src/plugins/projectexplorer/jsonwizard/jsonwizard.cpp b/src/plugins/projectexplorer/jsonwizard/jsonwizard.cpp
index 6dbfb6a78c..89fa5aed0c 100644
--- a/src/plugins/projectexplorer/jsonwizard/jsonwizard.cpp
+++ b/src/plugins/projectexplorer/jsonwizard/jsonwizard.cpp
@@ -493,7 +493,7 @@ void JsonWizard::openProjectForNode(Node *node)
     }
     QTC_ASSERT(projNode, return);
 
-    Utils::optional<FilePath> projFilePath = projNode->visibleAfterAddFileAction();
+    std::optional<FilePath> projFilePath = projNode->visibleAfterAddFileAction();
 
     if (projFilePath && !Core::EditorManager::openEditor(projFilePath.value())) {
             auto errorMessage = QCoreApplication::translate("ProjectExplorer::JsonWizard",
diff --git a/src/plugins/projectexplorer/kit.cpp b/src/plugins/projectexplorer/kit.cpp
index e1ccfe35d1..9ea9c6606c 100644
--- a/src/plugins/projectexplorer/kit.cpp
+++ b/src/plugins/projectexplorer/kit.cpp
@@ -16,7 +16,6 @@
 #include <utils/filepath.h>
 #include <utils/icon.h>
 #include <utils/macroexpander.h>
-#include <utils/optional.h>
 #include <utils/qtcassert.h>
 #include <utils/stringutils.h>
 #include <utils/utilsicons.h>
@@ -26,6 +25,7 @@
 #include <QUuid>
 
 #include <numeric>
+#include <optional>
 
 using namespace Core;
 using namespace Utils;
@@ -118,7 +118,7 @@ public:
     QHash<Id, QVariant> m_data;
     QSet<Id> m_sticky;
     QSet<Id> m_mutable;
-    optional<QSet<Id>> m_irrelevantAspects;
+    std::optional<QSet<Id>> m_irrelevantAspects;
     MacroExpander m_macroExpander;
 };
 
diff --git a/src/plugins/projectexplorer/makestep.cpp b/src/plugins/projectexplorer/makestep.cpp
index b29c964206..0d918967a4 100644
--- a/src/plugins/projectexplorer/makestep.cpp
+++ b/src/plugins/projectexplorer/makestep.cpp
@@ -17,7 +17,6 @@
 #include <utils/environment.h>
 #include <utils/hostosinfo.h>
 #include <utils/layoutbuilder.h>
-#include <utils/optional.h>
 #include <utils/pathchooser.h>
 #include <utils/qtcprocess.h>
 #include <utils/utilsicons.h>
@@ -29,6 +28,8 @@
 #include <QLineEdit>
 #include <QThread>
 
+#include <optional>
+
 using namespace Core;
 using namespace Utils;
 
@@ -197,12 +198,12 @@ bool MakeStep::jobCountOverridesMakeflags() const
     return m_overrideMakeflagsAspect->value();
 }
 
-static Utils::optional<int> argsJobCount(const QString &str)
+static std::optional<int> argsJobCount(const QString &str)
 {
     const QStringList args = ProcessArgs::splitArgs(str, HostOsInfo::hostOs());
     const int argIndex = Utils::indexOf(args, [](const QString &arg) { return arg.startsWith("-j"); });
     if (argIndex == -1)
-        return Utils::nullopt;
+        return std::nullopt;
     QString arg = args.at(argIndex);
     bool requireNumber = false;
     // -j [4] as separate arguments (or no value)
@@ -217,8 +218,8 @@ static Utils::optional<int> argsJobCount(const QString &str)
     bool ok = false;
     const int res = arg.toInt(&ok);
     if (!ok && requireNumber)
-        return Utils::nullopt;
-    return Utils::make_optional(ok && res > 0 ? res : 1000);
+        return std::nullopt;
+    return std::make_optional(ok && res > 0 ? res : 1000);
 }
 
 bool MakeStep::makeflagsJobCountMismatch() const
@@ -226,7 +227,7 @@ bool MakeStep::makeflagsJobCountMismatch() const
     const Environment env = makeEnvironment();
     if (!env.hasKey(MAKEFLAGS))
         return false;
-    Utils::optional<int> makeFlagsJobCount = argsJobCount(env.expandedValueForKey(MAKEFLAGS));
+    std::optional<int> makeFlagsJobCount = argsJobCount(env.expandedValueForKey(MAKEFLAGS));
     return makeFlagsJobCount.has_value() && *makeFlagsJobCount != m_userJobCountAspect->value();
 }
 
diff --git a/src/plugins/projectexplorer/msvctoolchain.cpp b/src/plugins/projectexplorer/msvctoolchain.cpp
index cbf4596599..e33c264ab4 100644
--- a/src/plugins/projectexplorer/msvctoolchain.cpp
+++ b/src/plugins/projectexplorer/msvctoolchain.cpp
@@ -15,7 +15,6 @@
 #include <utils/algorithm.h>
 #include <utils/environment.h>
 #include <utils/hostosinfo.h>
-#include <utils/optional.h>
 #include <utils/pathchooser.h>
 #include <utils/qtcassert.h>
 #include <utils/qtcprocess.h>
@@ -39,6 +38,8 @@
 #include <QComboBox>
 #include <QFormLayout>
 
+#include <optional>
+
 using namespace Utils;
 
 #define KEY_ROOT "ProjectExplorer.MsvcToolChain."
@@ -200,7 +201,7 @@ static QString windowsProgramFilesDir()
     return QDir::fromNativeSeparators(qtcEnvironmentVariable(programFilesC));
 }
 
-static Utils::optional<VisualStudioInstallation> installationFromPathAndVersion(
+static std::optional<VisualStudioInstallation> installationFromPathAndVersion(
     const QString &installationPath, const QVersionNumber &version)
 {
     QString vcVarsPath = QDir::fromNativeSeparators(installationPath);
@@ -215,7 +216,7 @@ static Utils::optional<VisualStudioInstallation> installationFromPathAndVersion(
     if (!QFileInfo(vcVarsAllPath).isFile()) {
         qWarning().noquote() << "Unable to find MSVC setup script "
                              << QDir::toNativeSeparators(vcVarsPath) << " in version " << version;
-        return Utils::nullopt;
+        return std::nullopt;
     }
 
     const QString versionString = version.toString();
@@ -229,7 +230,7 @@ static Utils::optional<VisualStudioInstallation> installationFromPathAndVersion(
 }
 
 // Detect build tools introduced with MSVC2017
-static Utils::optional<VisualStudioInstallation> detectCppBuildTools2017()
+static std::optional<VisualStudioInstallation> detectCppBuildTools2017()
 {
     const QString installPath = windowsProgramFilesDir()
                                 + "/Microsoft Visual Studio/2017/BuildTools";
@@ -237,7 +238,7 @@ static Utils::optional<VisualStudioInstallation> detectCppBuildTools2017()
     const QString vcVarsAllPath = vcVarsPath + "/vcvarsall.bat";
 
     if (!QFileInfo::exists(vcVarsAllPath))
-        return Utils::nullopt;
+        return std::nullopt;
 
     VisualStudioInstallation installation;
     installation.path = installPath;
@@ -314,7 +315,7 @@ static QVector<VisualStudioInstallation> detectVisualStudioFromVsWhere(const QSt
             continue;
         }
         const QString installationPath = value.toString();
-        Utils::optional<VisualStudioInstallation> installation
+        std::optional<VisualStudioInstallation> installation
             = installationFromPathAndVersion(installationPath, version);
 
         if (installation)
@@ -341,7 +342,7 @@ static QVector<VisualStudioInstallation> detectVisualStudioFromRegistry()
         if (!version.isNull()) {
             const QString installationPath = fixRegistryPath(vsRegistry.value(vsName).toString());
 
-            Utils::optional<VisualStudioInstallation> installation
+            std::optional<VisualStudioInstallation> installation
                 = installationFromPathAndVersion(installationPath, version);
             if (installation)
                 result.append(*installation);
@@ -747,7 +748,7 @@ void MsvcToolChain::environmentModifications(
     Utils::Environment outEnv;
     QMap<QString, QString> envPairs;
     Utils::EnvironmentItems diff;
-    Utils::optional<QString> error = generateEnvironmentSettings(inEnv,
+    std::optional<QString> error = generateEnvironmentSettings(inEnv,
                                                                  vcvarsBat,
                                                                  varsBatArg,
                                                                  envPairs);
@@ -1034,7 +1035,7 @@ ToolChain::MacroInspectionRunner MsvcToolChain::createMacroInspectionRunner() co
             return hasFlagEffectOnMacros(arg);
         });
 
-        const Utils::optional<MacroInspectionReport> cachedMacros = macroCache->check(filteredFlags);
+        const std::optional<MacroInspectionReport> cachedMacros = macroCache->check(filteredFlags);
         if (cachedMacros)
             return cachedMacros.value();
 
@@ -2072,7 +2073,7 @@ void MsvcToolChain::cancelMsvcToolChainDetection()
     envModThreadPool()->clear();
 }
 
-Utils::optional<QString> MsvcToolChain::generateEnvironmentSettings(const Utils::Environment &env,
+std::optional<QString> MsvcToolChain::generateEnvironmentSettings(const Utils::Environment &env,
                                                                     const QString &batchFile,
                                                                     const QString &batchArgs,
                                                                     QMap<QString, QString> &envPairs)
@@ -2163,7 +2164,7 @@ Utils::optional<QString> MsvcToolChain::generateEnvironmentSettings(const Utils:
         }
     }
 
-    return Utils::nullopt;
+    return std::nullopt;
 }
 
 bool MsvcToolChainFactory::canCreate() const
diff --git a/src/plugins/projectexplorer/msvctoolchain.h b/src/plugins/projectexplorer/msvctoolchain.h
index febc281d0f..cfbacad57b 100644
--- a/src/plugins/projectexplorer/msvctoolchain.h
+++ b/src/plugins/projectexplorer/msvctoolchain.h
@@ -11,7 +11,8 @@
 #include <QFutureWatcher>
 
 #include <utils/environment.h>
-#include <utils/optional.h>
+
+#include <optional>
 
 QT_FORWARD_DECLARE_CLASS(QLabel)
 QT_FORWARD_DECLARE_CLASS(QComboBox)
@@ -78,7 +79,7 @@ public:
     int priority() const override;
 
     static void cancelMsvcToolChainDetection();
-    static Utils::optional<QString> generateEnvironmentSettings(const Utils::Environment &env,
+    static std::optional<QString> generateEnvironmentSettings(const Utils::Environment &env,
                                                                 const QString &batchFile,
                                                                 const QString &batchArgs,
                                                                 QMap<QString, QString> &envPairs);
@@ -109,7 +110,7 @@ protected:
 
     struct GenerateEnvResult
     {
-        Utils::optional<QString> error;
+        std::optional<QString> error;
         Utils::EnvironmentItems environmentItems;
     };
     static void environmentModifications(QFutureInterface<GenerateEnvResult> &future,
diff --git a/src/plugins/projectexplorer/projectexplorer.cpp b/src/plugins/projectexplorer/projectexplorer.cpp
index cbcbf06e74..e81ad228c3 100644
--- a/src/plugins/projectexplorer/projectexplorer.cpp
+++ b/src/plugins/projectexplorer/projectexplorer.cpp
@@ -272,12 +272,12 @@ const char CUSTOM_PARSER_PREFIX_KEY[] = "ProjectExplorer/Settings/CustomParser";
 } // namespace Constants
 
 
-static Utils::optional<Environment> sysEnv(const Project *)
+static std::optional<Environment> sysEnv(const Project *)
 {
     return Environment::systemEnvironment();
 }
 
-static Utils::optional<Environment> buildEnv(const Project *project)
+static std::optional<Environment> buildEnv(const Project *project)
 {
     if (!project || !project->activeTarget() || !project->activeTarget()->activeBuildConfiguration())
         return {};
@@ -500,7 +500,7 @@ public:
     void openRecentProject(const FilePath &filePath);
     void removeFromRecentProjects(const FilePath &filePath);
     void updateUnloadProjectMenu();
-    using EnvironmentGetter = std::function<Utils::optional<Environment>(const Project *project)>;
+    using EnvironmentGetter = std::function<std::optional<Environment>(const Project *project)>;
     void openTerminalHere(const EnvironmentGetter &env);
     void openTerminalHereWithRunEnv();
 
diff --git a/src/plugins/projectexplorer/projectnodes.h b/src/plugins/projectexplorer/projectnodes.h
index 4f159b60ac..98dc5850e4 100644
--- a/src/plugins/projectexplorer/projectnodes.h
+++ b/src/plugins/projectexplorer/projectnodes.h
@@ -11,9 +11,9 @@
 
 #include <utils/fileutils.h>
 #include <utils/id.h>
-#include <utils/optional.h>
 
 #include <functional>
+#include <optional>
 #include <variant>
 
 namespace Utils { class MimeType; }
@@ -361,8 +361,8 @@ public:
     virtual bool addSubProject(const Utils::FilePath &proFile);
     virtual QStringList subProjectFileNamePatterns() const;
     virtual bool removeSubProject(const Utils::FilePath &proFilePath);
-    virtual Utils::optional<Utils::FilePath> visibleAfterAddFileAction() const {
-        return Utils::nullopt;
+    virtual std::optional<Utils::FilePath> visibleAfterAddFileAction() const {
+        return std::nullopt;
     }
 
     bool isFolderNodeType() const override { return false; }
diff --git a/src/plugins/projectexplorer/toolchaincache.h b/src/plugins/projectexplorer/toolchaincache.h
index 3c35d00914..22e1e690cc 100644
--- a/src/plugins/projectexplorer/toolchaincache.h
+++ b/src/plugins/projectexplorer/toolchaincache.h
@@ -8,7 +8,7 @@
 #include <QPair>
 #include <QVector>
 
-#include <utils/optional.h>
+#include <optional>
 
 namespace ProjectExplorer {
 
@@ -56,7 +56,7 @@ public:
         }
     }
 
-    Utils::optional<T> check(const K &key)
+    std::optional<T> check(const K &key)
     {
         QMutexLocker locker(&m_mutex);
         return checkImpl(key);
@@ -69,7 +69,7 @@ public:
     }
 
 private:
-    Utils::optional<T> checkImpl(const K &key)
+    std::optional<T> checkImpl(const K &key)
     {
         auto it = std::stable_partition(m_cache.begin(), m_cache.end(), [&](const CacheItem &ci) {
             return ci.first != key;
diff --git a/src/plugins/projectexplorer/userfileaccessor.cpp b/src/plugins/projectexplorer/userfileaccessor.cpp
index f6d91b935b..f1057fe962 100644
--- a/src/plugins/projectexplorer/userfileaccessor.cpp
+++ b/src/plugins/projectexplorer/userfileaccessor.cpp
@@ -183,11 +183,11 @@ static QString generateSuffix(const QString &suffix)
 }
 
 // Return path to shared directory for .user files, create if necessary.
-static inline Utils::optional<QString> defineExternalUserFileDir()
+static inline std::optional<QString> defineExternalUserFileDir()
 {
     const char userFilePathVariable[] = "QTC_USER_FILE_PATH";
     if (Q_LIKELY(!qtcEnvironmentVariableIsSet(userFilePathVariable)))
-        return nullopt;
+        return std::nullopt;
     const QFileInfo fi(qtcEnvironmentVariable(userFilePathVariable));
     const QString path = fi.absoluteFilePath();
     if (fi.isDir() || fi.isSymLink())
@@ -195,12 +195,12 @@ static inline Utils::optional<QString> defineExternalUserFileDir()
     if (fi.exists()) {
         qWarning() << userFilePathVariable << '=' << QDir::toNativeSeparators(path)
             << " points to an existing file";
-        return nullopt;
+        return std::nullopt;
     }
     QDir dir;
     if (!dir.mkpath(path)) {
         qWarning() << "Cannot create: " << QDir::toNativeSeparators(path);
-        return nullopt;
+        return std::nullopt;
     }
     return path;
 }
@@ -235,7 +235,7 @@ static QString makeRelative(QString path)
 // Return complete file path of the .user file.
 static FilePath externalUserFilePath(const Utils::FilePath &projectFilePath, const QString &suffix)
 {
-    static const optional<QString> externalUserFileDir = defineExternalUserFileDir();
+    static const std::optional<QString> externalUserFileDir = defineExternalUserFileDir();
 
     if (externalUserFileDir) {
         // Recreate the relative project file hierarchy under the shared directory.
@@ -328,7 +328,7 @@ UserFileAccessor::merge(const MergingSettingsAccessor::SettingsMergeData &global
     const QVariant secondaryValue = local.secondary.value(key);
 
     if (mainValue.isNull() && secondaryValue.isNull())
-        return nullopt;
+        return std::nullopt;
 
     if (isHouseKeepingKey(key) || global.key == USER_STICKY_KEYS_KEY)
         return qMakePair(key, mainValue);
@@ -357,14 +357,14 @@ SettingsMergeFunction UserFileAccessor::userStickyTrackerFunction(QStringList &s
         const QVariant secondary = local.secondary.value(key);
 
         if (main.isNull()) // skip stuff not in main!
-            return nullopt;
+            return std::nullopt;
 
         if (isHouseKeepingKey(key))
             return qMakePair(key, main);
 
         // Ignore house keeping keys:
         if (key == USER_STICKY_KEYS_KEY)
-            return nullopt;
+            return std::nullopt;
 
         // Track keys that changed in main from the value in secondary:
         if (main != secondary && !secondary.isNull() && !stickyKeys.contains(global.key))
diff --git a/src/plugins/qbsprojectmanager/qbssession.cpp b/src/plugins/qbsprojectmanager/qbssession.cpp
index 050a5cf1be..9259f59a82 100644
--- a/src/plugins/qbsprojectmanager/qbssession.cpp
+++ b/src/plugins/qbsprojectmanager/qbssession.cpp
@@ -135,7 +135,7 @@ public:
     QEventLoop eventLoop;
     QJsonObject reply;
     QHash<QString, QStringList> generatedFilesForSources;
-    optional<Error> lastError;
+    std::optional<Error> lastError;
     State state = State::Inactive;
 };
 
@@ -215,7 +215,7 @@ QbsSession::~QbsSession()
     delete d;
 }
 
-optional<QbsSession::Error> QbsSession::lastError() const
+std::optional<QbsSession::Error> QbsSession::lastError() const
 {
     return d->lastError;
 }
diff --git a/src/plugins/qbsprojectmanager/qbssession.h b/src/plugins/qbsprojectmanager/qbssession.h
index ad49d86aca..8ad9972d6d 100644
--- a/src/plugins/qbsprojectmanager/qbssession.h
+++ b/src/plugins/qbsprojectmanager/qbssession.h
@@ -4,7 +4,6 @@
 #pragma once
 
 #include <utils/fileutils.h>
-#include <utils/optional.h>
 
 #include <QHash>
 #include <QJsonObject>
@@ -14,6 +13,7 @@
 #include <QVariant>
 
 #include <functional>
+#include <optional>
 
 namespace ProjectExplorer { class Target; }
 
@@ -102,7 +102,7 @@ public:
     enum class State { Initializing, Active, Inactive };
     enum class Error { QbsFailedToStart, QbsQuit, ProtocolError, VersionMismatch };
 
-    Utils::optional<Error> lastError() const;
+    std::optional<Error> lastError() const;
     static QString errorString(Error error);
     QJsonObject projectData() const;
 
diff --git a/src/plugins/qmldesigner/components/curveeditor/detail/keyframeitem.cpp b/src/plugins/qmldesigner/components/curveeditor/detail/keyframeitem.cpp
index f09b211c0e..02bacc2041 100644
--- a/src/plugins/qmldesigner/components/curveeditor/detail/keyframeitem.cpp
+++ b/src/plugins/qmldesigner/components/curveeditor/detail/keyframeitem.cpp
@@ -449,7 +449,7 @@ void KeyframeItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
     bool ok;
     m_firstPos = m_transform.inverted(&ok).map(event->scenePos());
     if (!ok)
-        m_firstPos = Utils::nullopt;
+        m_firstPos = std::nullopt;
 
     SelectableItem::mousePressEvent(event);
     if (auto *curveItem = qgraphicsitem_cast<CurveItem *>(parentItem()))
@@ -458,7 +458,7 @@ void KeyframeItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
 
 void KeyframeItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 {
-    m_firstPos = Utils::nullopt;
+    m_firstPos = std::nullopt;
     SelectableItem::mouseReleaseEvent(event);
     if (auto *curveItem = qgraphicsitem_cast<CurveItem *>(parentItem()))
         curveItem->setHandleVisibility(true);
diff --git a/src/plugins/qmldesigner/components/curveeditor/detail/keyframeitem.h b/src/plugins/qmldesigner/components/curveeditor/detail/keyframeitem.h
index 2a8251d962..d02c1a9b23 100644
--- a/src/plugins/qmldesigner/components/curveeditor/detail/keyframeitem.h
+++ b/src/plugins/qmldesigner/components/curveeditor/detail/keyframeitem.h
@@ -8,10 +8,10 @@
 #include "keyframe.h"
 #include "selectableitem.h"
 
-#include <utils/optional.h>
-
 #include <QGraphicsObject>
 
+#include <optional>
+
 namespace QmlDesigner {
 
 class HandleItem;
@@ -111,8 +111,8 @@ private:
 
     HandleItem *m_right;
 
-    Utils::optional< QPointF > m_firstPos;
-    Utils::optional< QPointF > m_validPos;
+    std::optional< QPointF > m_firstPos;
+    std::optional< QPointF > m_validPos;
 
     bool m_visibleOverride = true;
 
diff --git a/src/plugins/qmldesigner/components/timelineeditor/timelinesettingsmodel.cpp b/src/plugins/qmldesigner/components/timelineeditor/timelinesettingsmodel.cpp
index 7ad9d264cb..9aaa1a38cd 100644
--- a/src/plugins/qmldesigner/components/timelineeditor/timelinesettingsmodel.cpp
+++ b/src/plugins/qmldesigner/components/timelineeditor/timelinesettingsmodel.cpp
@@ -9,7 +9,6 @@
 #include <variantproperty.h>
 #include <qmlvisualnode.h>
 
-#include <utils/optional.h>
 #include <utils/qtcassert.h>
 
 #include <QComboBox>
@@ -19,9 +18,11 @@
 #include <QStyledItemDelegate>
 #include <QTimer>
 
+#include <optional>
+
 namespace QmlDesigner {
 
-static void setDataForFixedFrame(QStandardItem *item, Utils::optional<int> fixedValue)
+static void setDataForFixedFrame(QStandardItem *item, std::optional<int> fixedValue)
 {
     if (fixedValue)
         item->setData(fixedValue.value(), Qt::EditRole);
@@ -172,7 +173,7 @@ void TimelineSettingsModel::setupDelegates(QAbstractItemView *view)
     view->setItemDelegate(new TimelineEditorDelegate);
 }
 
-static Utils::optional<int> propertyValueForState(const ModelNode &modelNode,
+static std::optional<int> propertyValueForState(const ModelNode &modelNode,
                                  QmlModelState state,
                                  const PropertyName &propertyName)
 {
diff --git a/src/plugins/qmldesigner/designercore/imagecache/asynchronousexplicitimagecache.cpp b/src/plugins/qmldesigner/designercore/imagecache/asynchronousexplicitimagecache.cpp
index f0aef75895..2c3446bbe3 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/asynchronousexplicitimagecache.cpp
+++ b/src/plugins/qmldesigner/designercore/imagecache/asynchronousexplicitimagecache.cpp
@@ -93,7 +93,7 @@ void AsynchronousExplicitImageCache::clean()
     clearEntries();
 }
 
-Utils::optional<AsynchronousExplicitImageCache::RequestEntry> AsynchronousExplicitImageCache::getEntry()
+std::optional<AsynchronousExplicitImageCache::RequestEntry> AsynchronousExplicitImageCache::getEntry()
 {
     std::unique_lock lock{m_mutex};
 
diff --git a/src/plugins/qmldesigner/designercore/imagecache/asynchronousimagecache.cpp b/src/plugins/qmldesigner/designercore/imagecache/asynchronousimagecache.cpp
index 4cf140634c..6d08443e9e 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/asynchronousimagecache.cpp
+++ b/src/plugins/qmldesigner/designercore/imagecache/asynchronousimagecache.cpp
@@ -123,7 +123,7 @@ void AsynchronousImageCache::clean()
     m_generator.clean();
 }
 
-Utils::optional<AsynchronousImageCache::Entry> AsynchronousImageCache::getEntry()
+std::optional<AsynchronousImageCache::Entry> AsynchronousImageCache::getEntry()
 {
     std::unique_lock lock{m_mutex};
 
diff --git a/src/plugins/qmldesigner/designercore/imagecache/asynchronousimagefactory.cpp b/src/plugins/qmldesigner/designercore/imagecache/asynchronousimagefactory.cpp
index d8c93fb98b..de738862a3 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/asynchronousimagefactory.cpp
+++ b/src/plugins/qmldesigner/designercore/imagecache/asynchronousimagefactory.cpp
@@ -69,7 +69,7 @@ void AsynchronousImageFactory::waitForEntries()
         m_condition.wait(lock, [&] { return m_entries.size() || m_finishing; });
 }
 
-Utils::optional<AsynchronousImageFactory::Entry> AsynchronousImageFactory::getEntry()
+std::optional<AsynchronousImageFactory::Entry> AsynchronousImageFactory::getEntry()
 {
     std::unique_lock lock{m_mutex};
 
diff --git a/src/plugins/qmldesigner/designercore/imagecache/asynchronousimagefactory.h b/src/plugins/qmldesigner/designercore/imagecache/asynchronousimagefactory.h
index fe10d947bc..c7a25d1d47 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/asynchronousimagefactory.h
+++ b/src/plugins/qmldesigner/designercore/imagecache/asynchronousimagefactory.h
@@ -5,12 +5,12 @@
 
 #include "imagecacheauxiliarydata.h"
 
-#include <utils/optional.h>
 #include <utils/smallstring.h>
 
 #include <condition_variable>
 #include <deque>
 #include <mutex>
+#include <optional>
 #include <thread>
 
 namespace QmlDesigner {
@@ -55,7 +55,7 @@ private:
                   ImageCache::AuxiliaryData &&auxiliaryData);
     bool isRunning();
     void waitForEntries();
-    Utils::optional<Entry> getEntry();
+    std::optional<Entry> getEntry();
     void request(Utils::SmallStringView name,
                  Utils::SmallStringView extraId,
                  ImageCache::AuxiliaryData auxiliaryData,
diff --git a/src/plugins/qmldesigner/designercore/imagecache/imagecachestorageinterface.h b/src/plugins/qmldesigner/designercore/imagecache/imagecachestorageinterface.h
index 538261b0d1..00f4ce4ecb 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/imagecachestorageinterface.h
+++ b/src/plugins/qmldesigner/designercore/imagecache/imagecachestorageinterface.h
@@ -7,16 +7,17 @@
 #include <QImage>
 
 #include <sqlitetimestamp.h>
-#include <utils/optional.h>
 #include <utils/smallstringview.h>
 
+#include <optional>
+
 namespace QmlDesigner {
 
 class ImageCacheStorageInterface
 {
 public:
-    using ImageEntry = Utils::optional<QImage>;
-    using IconEntry = Utils::optional<QIcon>;
+    using ImageEntry = std::optional<QImage>;
+    using IconEntry = std::optional<QIcon>;
 
     virtual ImageEntry fetchImage(Utils::SmallStringView name,
                                   Sqlite::TimeStamp minimumTimeStamp) const = 0;
diff --git a/src/plugins/qmldesigner/designercore/include/asynchronousexplicitimagecache.h b/src/plugins/qmldesigner/designercore/include/asynchronousexplicitimagecache.h
index 5b4e7bc787..9ac6d7a933 100644
--- a/src/plugins/qmldesigner/designercore/include/asynchronousexplicitimagecache.h
+++ b/src/plugins/qmldesigner/designercore/include/asynchronousexplicitimagecache.h
@@ -5,12 +5,11 @@
 
 #include "asynchronousimagecacheinterface.h"
 
-#include <utils/optional.h>
-
 #include <condition_variable>
 #include <deque>
 #include <functional>
 #include <mutex>
+#include <optional>
 #include <thread>
 
 namespace QmlDesigner {
@@ -59,7 +58,7 @@ private:
         RequestType requestType = RequestType::Image;
     };
 
-    Utils::optional<RequestEntry> getEntry();
+    std::optional<RequestEntry> getEntry();
     void addEntry(Utils::PathString &&name,
                   Utils::SmallString &&extraId,
                   ImageCache::CaptureImageCallback &&captureCallback,
diff --git a/src/plugins/qmldesigner/designercore/include/asynchronousimagecache.h b/src/plugins/qmldesigner/designercore/include/asynchronousimagecache.h
index 9eac8575cb..d547a0979e 100644
--- a/src/plugins/qmldesigner/designercore/include/asynchronousimagecache.h
+++ b/src/plugins/qmldesigner/designercore/include/asynchronousimagecache.h
@@ -5,12 +5,11 @@
 
 #include "asynchronousimagecacheinterface.h"
 
-#include <utils/optional.h>
-
 #include <condition_variable>
 #include <deque>
 #include <functional>
 #include <mutex>
+#include <optional>
 #include <thread>
 
 namespace QmlDesigner {
@@ -69,7 +68,7 @@ private:
         RequestType requestType = RequestType::Image;
     };
 
-    Utils::optional<Entry> getEntry();
+    std::optional<Entry> getEntry();
     void addEntry(Utils::PathString &&name,
                   Utils::SmallString &&extraId,
                   ImageCache::CaptureImageCallback &&captureCallback,
diff --git a/src/plugins/qmldesigner/designercore/include/modelcache.h b/src/plugins/qmldesigner/designercore/include/modelcache.h
index 39eae38890..63eef0d451 100644
--- a/src/plugins/qmldesigner/designercore/include/modelcache.h
+++ b/src/plugins/qmldesigner/designercore/include/modelcache.h
@@ -7,11 +7,11 @@
 
 #include <model.h>
 
-#include <utils/optional.h>
-
 #include <QHash>
 #include <QQueue>
 
+#include <optional>
+
 namespace QmlDesigner {
 
 template<class DataType>
@@ -42,7 +42,7 @@ public:
         }
     }
 
-    Utils::optional<DataType> take(Model *model)
+    std::optional<DataType> take(Model *model)
     {
         if (!m_content.contains(model))
             return {};
diff --git a/src/plugins/qmldesigner/designercore/include/modelnode.h b/src/plugins/qmldesigner/designercore/include/modelnode.h
index 448f49ebe6..319d692803 100644
--- a/src/plugins/qmldesigner/designercore/include/modelnode.h
+++ b/src/plugins/qmldesigner/designercore/include/modelnode.h
@@ -7,14 +7,13 @@
 #include "abstractproperty.h"
 #include "qmldesignercorelib_global.h"
 
-#include <utils/optional.h>
-
 #include <QPointer>
 #include <QList>
 #include <QVector>
 #include <QVariant>
 
 #include <memory>
+#include <optional>
 
 QT_BEGIN_NAMESPACE
 class QTextStream;
@@ -178,8 +177,8 @@ public:
     static int variantUserType();
     QVariant toVariant() const;
 
-    Utils::optional<QVariant> auxiliaryData(AuxiliaryDataKeyView key) const;
-    Utils::optional<QVariant> auxiliaryData(AuxiliaryDataType type, Utils::SmallStringView name) const;
+    std::optional<QVariant> auxiliaryData(AuxiliaryDataKeyView key) const;
+    std::optional<QVariant> auxiliaryData(AuxiliaryDataType type, Utils::SmallStringView name) const;
     QVariant auxiliaryDataWithDefault(AuxiliaryDataType type, Utils::SmallStringView name) const;
     QVariant auxiliaryDataWithDefault(AuxiliaryDataKeyView key) const;
     void setAuxiliaryData(AuxiliaryDataKeyView key, const QVariant &data) const;
diff --git a/src/plugins/qmldesigner/designercore/include/nodemetainfo.h b/src/plugins/qmldesigner/designercore/include/nodemetainfo.h
index f654f6f941..f379b3e206 100644
--- a/src/plugins/qmldesigner/designercore/include/nodemetainfo.h
+++ b/src/plugins/qmldesigner/designercore/include/nodemetainfo.h
@@ -11,12 +11,11 @@
 #include <projectstorage/projectstoragetypes.h>
 #include <projectstorageids.h>
 
-#include <utils/optional.h>
-
 #include <QList>
 #include <QString>
 #include <QIcon>
 
+#include <optional>
 #include <vector>
 
 QT_BEGIN_NAMESPACE
@@ -170,7 +169,7 @@ private:
 private:
     TypeId m_typeId;
     NotNullPointer<const ProjectStorage<Sqlite::Database>> m_projectStorage = {};
-    mutable Utils::optional<Storage::Info::Type> m_typeData;
+    mutable std::optional<Storage::Info::Type> m_typeData;
     QSharedPointer<class NodeMetaInfoPrivate> m_privateData;
 };
 
diff --git a/src/plugins/qmldesigner/designercore/include/propertymetainfo.h b/src/plugins/qmldesigner/designercore/include/propertymetainfo.h
index a3fc6943b4..c216e5a6fe 100644
--- a/src/plugins/qmldesigner/designercore/include/propertymetainfo.h
+++ b/src/plugins/qmldesigner/designercore/include/propertymetainfo.h
@@ -9,11 +9,10 @@
 #include <projectstorage/projectstoragetypes.h>
 #include <projectstorageids.h>
 
-#include <utils/optional.h>
-
 #include <QSharedPointer>
 #include <QString>
 
+#include <optional>
 #include <vector>
 
 namespace QmlDesigner {
@@ -50,7 +49,7 @@ private:
     PropertyName m_propertyName;
     PropertyDeclarationId m_id;
     NotNullPointer<const ProjectStorage<Sqlite::Database>> m_projectStorage;
-    mutable Utils::optional<Storage::Info::PropertyDeclaration> m_propertyData;
+    mutable std::optional<Storage::Info::PropertyDeclaration> m_propertyData;
 };
 
 using PropertyMetaInfos = std::vector<PropertyMetaInfo>;
diff --git a/src/plugins/qmldesigner/designercore/include/textmodifier.h b/src/plugins/qmldesigner/designercore/include/textmodifier.h
index a9aa51133a..2e8bbd0ba1 100644
--- a/src/plugins/qmldesigner/designercore/include/textmodifier.h
+++ b/src/plugins/qmldesigner/designercore/include/textmodifier.h
@@ -7,12 +7,13 @@
 
 #include <qmljs/qmljsdocument.h>
 #include <texteditor/tabsettings.h>
-#include <utils/optional.h>
 
 #include <QObject>
 #include <QTextCursor>
 #include <QTextDocument>
 
+#include <optional>
+
 namespace TextEditor { class TabSettings; }
 
 namespace QmlDesigner {
diff --git a/src/plugins/qmldesigner/designercore/model/internalnode.cpp b/src/plugins/qmldesigner/designercore/model/internalnode.cpp
index 60b9b95473..87199c0c87 100644
--- a/src/plugins/qmldesigner/designercore/model/internalnode.cpp
+++ b/src/plugins/qmldesigner/designercore/model/internalnode.cpp
@@ -52,7 +52,7 @@ auto find(Type &&auxiliaryDatas, AuxiliaryDataKeyView key)
 
 } // namespace
 
-Utils::optional<QVariant> InternalNode::auxiliaryData(AuxiliaryDataKeyView key) const
+std::optional<QVariant> InternalNode::auxiliaryData(AuxiliaryDataKeyView key) const
 {
     auto found = find(m_auxiliaryDatas, key);
 
diff --git a/src/plugins/qmldesigner/designercore/model/internalnode_p.h b/src/plugins/qmldesigner/designercore/model/internalnode_p.h
index 0600cee32c..7b0daa1d2e 100644
--- a/src/plugins/qmldesigner/designercore/model/internalnode_p.h
+++ b/src/plugins/qmldesigner/designercore/model/internalnode_p.h
@@ -12,7 +12,6 @@
 #include "internalvariantproperty.h"
 
 #include <auxiliarydata.h>
-#include <utils/optional.h>
 #include <projectstorageids.h>
 #include <utils/smallstring.h>
 
@@ -22,11 +21,11 @@
 #include <QStringList>
 #include <QWeakPointer>
 
+#include <memory>
+#include <optional>
 #include <type_traits>
 #include <vector>
 
-#include <memory>
-
 namespace QmlDesigner {
 
 namespace Internal {
@@ -61,7 +60,7 @@ public:
     void setParentProperty(const InternalNodeAbstractProperty::Pointer &parent);
     void resetParentProperty();
 
-    Utils::optional<QVariant> auxiliaryData(AuxiliaryDataKeyView key) const;
+    std::optional<QVariant> auxiliaryData(AuxiliaryDataKeyView key) const;
     bool setAuxiliaryData(AuxiliaryDataKeyView key, const QVariant &data);
     bool removeAuxiliaryData(AuxiliaryDataKeyView key);
     bool hasAuxiliaryData(AuxiliaryDataKeyView key) const;
diff --git a/src/plugins/qmldesigner/designercore/model/modelnode.cpp b/src/plugins/qmldesigner/designercore/model/modelnode.cpp
index 04f5276f84..c8306f53f3 100644
--- a/src/plugins/qmldesigner/designercore/model/modelnode.cpp
+++ b/src/plugins/qmldesigner/designercore/model/modelnode.cpp
@@ -1038,7 +1038,7 @@ QVariant ModelNode::toVariant() const
     return QVariant::fromValue(*this);
 }
 
-Utils::optional<QVariant> ModelNode::auxiliaryData(AuxiliaryDataKeyView key) const
+std::optional<QVariant> ModelNode::auxiliaryData(AuxiliaryDataKeyView key) const
 {
     if (!isValid())
         throw InvalidModelNodeException(__LINE__, __FUNCTION__, __FILE__);
@@ -1046,7 +1046,7 @@ Utils::optional<QVariant> ModelNode::auxiliaryData(AuxiliaryDataKeyView key) con
     return m_internalNode->auxiliaryData(key);
 }
 
-Utils::optional<QVariant> ModelNode::auxiliaryData(AuxiliaryDataType type,
+std::optional<QVariant> ModelNode::auxiliaryData(AuxiliaryDataType type,
                                                    Utils::SmallStringView name) const
 {
     return auxiliaryData({type, name});
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h b/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h
index 13db42de19..1be507f76a 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h
+++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h
@@ -15,10 +15,10 @@
 #include <sqlitetransaction.h>
 
 #include <utils/algorithm.h>
-#include <utils/optional.h>
 #include <utils/set_algorithm.h>
 
 #include <algorithm>
+#include <optional>
 #include <tuple>
 #include <type_traits>
 #include <utility>
@@ -161,7 +161,7 @@ public:
             .template valueWithTransaction<PropertyDeclarationId>(typeId, propertyName);
     }
 
-    Utils::optional<Storage::Info::PropertyDeclaration> propertyDeclaration(
+    std::optional<Storage::Info::PropertyDeclaration> propertyDeclaration(
         PropertyDeclarationId propertyDeclarationId) const
     {
         return selectPropertyDeclarationForPropertyDeclarationIdStatement
@@ -169,7 +169,7 @@ public:
                 propertyDeclarationId);
     }
 
-    Utils::optional<Storage::Info::Type> type(TypeId typeId) const
+    std::optional<Storage::Info::Type> type(TypeId typeId) const
     {
         return selectInfoTypeByTypeIdStatement.template optionalValueWithTransaction<Storage::Info::Type>(
             typeId);
@@ -187,7 +187,7 @@ public:
             .template valuesWithTransaction<Utils::SmallString>(32, typeId);
     }
 
-    Utils::optional<Utils::SmallString> propertyName(PropertyDeclarationId propertyDeclarationId) const
+    std::optional<Utils::SmallString> propertyName(PropertyDeclarationId propertyDeclarationId) const
     {
         return selectPropertyNameStatement.template optionalValueWithTransaction<Utils::SmallString>(
             propertyDeclarationId);
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/storagecache.h b/src/plugins/qmldesigner/designercore/projectstorage/storagecache.h
index d9210b9776..ded352c831 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/storagecache.h
+++ b/src/plugins/qmldesigner/designercore/projectstorage/storagecache.h
@@ -9,11 +9,11 @@
 #include "storagecachefwd.h"
 
 #include <utils/algorithm.h>
-#include <utils/optional.h>
 #include <utils/set_algorithm.h>
 #include <utils/smallstringfwd.h>
 
 #include <algorithm>
+#include <optional>
 #include <shared_mutex>
 #include <vector>
 
diff --git a/src/plugins/qmljstools/qmljscodestylesettings.h b/src/plugins/qmljstools/qmljscodestylesettings.h
index 36b97f39c4..c10155873d 100644
--- a/src/plugins/qmljstools/qmljscodestylesettings.h
+++ b/src/plugins/qmljstools/qmljscodestylesettings.h
@@ -5,10 +5,10 @@
 
 #include "qmljstools_global.h"
 
-#include <utils/optional.h>
-
 #include <QVariantMap>
 
+#include <optional>
+
 namespace TextEditor { class TabSettings; }
 
 namespace QmlJSTools {
diff --git a/src/plugins/qtsupport/qtoptionspage.cpp b/src/plugins/qtsupport/qtoptionspage.cpp
index ffa9b4c3ed..8b2115f7c1 100644
--- a/src/plugins/qtsupport/qtoptionspage.cpp
+++ b/src/plugins/qtsupport/qtoptionspage.cpp
@@ -814,7 +814,7 @@ static QString qtVersionsFile(const QString &baseDir)
            + Core::Constants::IDE_ID + '/' + "qtversion.xml";
 }
 
-static Utils::optional<FilePath> currentlyLinkedQtDir(bool *hasInstallSettings)
+static std::optional<FilePath> currentlyLinkedQtDir(bool *hasInstallSettings)
 {
     const QString installSettingsFilePath = settingsFile(Core::ICore::resourcePath().toString());
     const bool installSettingsExist = QFile::exists(installSettingsFilePath);
@@ -841,7 +841,7 @@ static bool canLinkWithQt(QString *toolTip)
 {
     bool canLink = true;
     bool installSettingsExist;
-    const Utils::optional<FilePath> installSettingsValue = currentlyLinkedQtDir(
+    const std::optional<FilePath> installSettingsValue = currentlyLinkedQtDir(
         &installSettingsExist);
     QStringList tip;
     tip << linkingPurposeText();
@@ -929,7 +929,7 @@ static QStringList qtversionFilesToCheck()
     return Utils::transform(kSubdirsToCheck, [](const QString &dir) { return qtVersionsFile(dir); });
 }
 
-static Utils::optional<QString> settingsDirForQtDir(const QString &qtDir)
+static std::optional<QString> settingsDirForQtDir(const QString &qtDir)
 {
     const QStringList dirsToCheck = Utils::transform(kSubdirsToCheck, [qtDir](const QString &dir) {
         return QString(qtDir + '/' + dir);
@@ -995,7 +995,7 @@ void QtOptionsPageWidget::linkWithQt()
             return false;
         return validateQtInstallDir(input, errorString);
     });
-    const Utils::optional<FilePath> currentLink = currentlyLinkedQtDir(nullptr);
+    const std::optional<FilePath> currentLink = currentlyLinkedQtDir(nullptr);
     pathInput->setFilePath(currentLink ? *currentLink : defaultQtInstallationPath());
     pathInput->setAllowPathFromDevice(true);
     auto buttons = new QDialogButtonBox;
@@ -1026,7 +1026,7 @@ void QtOptionsPageWidget::linkWithQt()
 
     dialog.exec();
     if (dialog.result() == QDialog::Accepted) {
-        const Utils::optional<QString> settingsDir = settingsDirForQtDir(pathInput->rawFilePath().toString());
+        const std::optional<QString> settingsDir = settingsDirForQtDir(pathInput->rawFilePath().toString());
         if (QTC_GUARD(settingsDir)) {
             QSettings(settingsFile(Core::ICore::resourcePath().toString()), QSettings::IniFormat)
                 .setValue(kInstallSettingsKey, *settingsDir);
diff --git a/src/plugins/studiowelcome/algorithm.h b/src/plugins/studiowelcome/algorithm.h
index 4956b2d335..fa05869002 100644
--- a/src/plugins/studiowelcome/algorithm.h
+++ b/src/plugins/studiowelcome/algorithm.h
@@ -10,14 +10,14 @@ namespace Utils {
 
 //////// FIND
 template<typename C, typename F>
-[[nodiscard]] typename Utils::optional<typename C::value_type> findOptional(const C &container,
+[[nodiscard]] typename std::optional<typename C::value_type> findOptional(const C &container,
                                                                             F function)
 {
     auto begin = std::cbegin(container);
     auto end = std::cend(container);
 
     auto it = std::find_if(begin, end, function);
-    return it == end ? nullopt : make_optional(*it);
+    return it == end ? std::nullopt : std::make_optional(*it);
 }
 
 template<typename C>
diff --git a/src/plugins/studiowelcome/presetmodel.cpp b/src/plugins/studiowelcome/presetmodel.cpp
index e14659c6a8..bf2b880521 100644
--- a/src/plugins/studiowelcome/presetmodel.cpp
+++ b/src/plugins/studiowelcome/presetmodel.cpp
@@ -2,10 +2,11 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
 
 #include "presetmodel.h"
-#include <utils/optional.h>
 
 #include "algorithm.h"
 
+#include <optional>
+
 using namespace StudioWelcome;
 
 constexpr int NameRole = Qt::UserRole;
diff --git a/src/plugins/studiowelcome/presetmodel.h b/src/plugins/studiowelcome/presetmodel.h
index 43588ccfc0..b192a11c57 100644
--- a/src/plugins/studiowelcome/presetmodel.h
+++ b/src/plugins/studiowelcome/presetmodel.h
@@ -8,11 +8,12 @@
 #include <QUrl>
 
 #include <utils/filepath.h>
-#include <utils/optional.h>
 #include <utils/qtcassert.h>
 
 #include "userpresets.h"
 
+#include <optional>
+
 namespace Utils {
 class Wizard;
 }
diff --git a/src/plugins/texteditor/indenter.h b/src/plugins/texteditor/indenter.h
index 73ef022051..ccaae3e2e8 100644
--- a/src/plugins/texteditor/indenter.h
+++ b/src/plugins/texteditor/indenter.h
@@ -4,11 +4,12 @@
 #pragma once
 
 #include <utils/fileutils.h>
-#include <utils/optional.h>
 #include <utils/textutils.h>
 
 #include <QMap>
 #include <QTextBlock>
+
+#include <optional>
 #include <vector>
 
 namespace Utils {
@@ -75,7 +76,7 @@ public:
                                                      const TabSettings &tabSettings,
                                                      int cursorPositionInEditor = -1)
         = 0;
-    virtual Utils::optional<TabSettings> tabSettings() const = 0;
+    virtual std::optional<TabSettings> tabSettings() const = 0;
 
     // Indent a text block based on previous line. Default does nothing
     virtual void indentBlock(const QTextBlock &block,
@@ -98,7 +99,7 @@ public:
                           int cursorPositionInEditor = -1)
         = 0;
 
-    virtual Utils::optional<int> margin() const { return Utils::nullopt; }
+    virtual std::optional<int> margin() const { return std::nullopt; }
 
 protected:
     QTextDocument *m_doc;
diff --git a/src/plugins/texteditor/texteditor.cpp b/src/plugins/texteditor/texteditor.cpp
index def49c05ed..064ea1ceea 100644
--- a/src/plugins/texteditor/texteditor.cpp
+++ b/src/plugins/texteditor/texteditor.cpp
@@ -583,7 +583,7 @@ public:
 
     void transformSelectedLines(ListTransformationMethod method);
 
-    void slotUpdateExtraAreaWidth(Utils::optional<int> width = {});
+    void slotUpdateExtraAreaWidth(std::optional<int> width = {});
     void slotUpdateRequest(const QRect &r, int dy);
     void slotUpdateBlockNotify(const QTextBlock &);
     void updateTabStops();
@@ -4840,7 +4840,7 @@ int TextEditorWidget::extraAreaWidth(int *markWidthPtr) const
     return space;
 }
 
-void TextEditorWidgetPrivate::slotUpdateExtraAreaWidth(optional<int> width)
+void TextEditorWidgetPrivate::slotUpdateExtraAreaWidth(std::optional<int> width)
 {
     if (!width.has_value())
         width = q->extraAreaWidth();
@@ -5389,7 +5389,7 @@ void TextEditorWidget::mouseMoveEvent(QMouseEvent *e)
         }
     }
 
-    static Utils::optional<MultiTextCursor> startMouseMoveCursor;
+    static std::optional<MultiTextCursor> startMouseMoveCursor;
     if (e->buttons() == Qt::LeftButton && e->modifiers() & Qt::AltModifier) {
         if (!startMouseMoveCursor.has_value()) {
             startMouseMoveCursor = multiTextCursor();
diff --git a/src/plugins/texteditor/textindenter.cpp b/src/plugins/texteditor/textindenter.cpp
index fbe08bdde9..0927bec357 100644
--- a/src/plugins/texteditor/textindenter.cpp
+++ b/src/plugins/texteditor/textindenter.cpp
@@ -122,7 +122,7 @@ void TextIndenter::reindent(const QTextCursor &cursor,
     }
 }
 
-Utils::optional<TabSettings> TextIndenter::tabSettings() const
+std::optional<TabSettings> TextIndenter::tabSettings() const
 {
-    return Utils::optional<TabSettings>();
+    return std::optional<TabSettings>();
 }
diff --git a/src/plugins/texteditor/textindenter.h b/src/plugins/texteditor/textindenter.h
index b929794bf0..66c8eff7b5 100644
--- a/src/plugins/texteditor/textindenter.h
+++ b/src/plugins/texteditor/textindenter.h
@@ -42,7 +42,7 @@ public:
     void reindent(const QTextCursor &cursor,
                   const TabSettings &tabSettings,
                   int cursorPositionInEditor = -1) override;
-    Utils::optional<TabSettings> tabSettings() const override;
+    std::optional<TabSettings> tabSettings() const override;
 };
 
 } // namespace TextEditor
diff --git a/src/plugins/texteditor/textmark.cpp b/src/plugins/texteditor/textmark.cpp
index 495c44463d..1ca67b597b 100644
--- a/src/plugins/texteditor/textmark.cpp
+++ b/src/plugins/texteditor/textmark.cpp
@@ -354,7 +354,7 @@ const QIcon TextMark::icon() const
     return m_iconProvider ? m_iconProvider() : m_icon;
 }
 
-Utils::optional<Theme::Color> TextMark::color() const
+std::optional<Theme::Color> TextMark::color() const
 {
     return m_color;
 }
diff --git a/src/plugins/texteditor/textmark.h b/src/plugins/texteditor/textmark.h
index c6bfbc45a8..ed0816224b 100644
--- a/src/plugins/texteditor/textmark.h
+++ b/src/plugins/texteditor/textmark.h
@@ -7,13 +7,14 @@
 
 #include <utils/fileutils.h>
 #include <utils/id.h>
-#include <utils/optional.h>
 #include <utils/theme/theme.h>
 
 #include <QCoreApplication>
 #include <QIcon>
 #include <QVector>
 
+#include <optional>
+
 QT_BEGIN_NAMESPACE
 class QAction;
 class QGridLayout;
@@ -90,7 +91,7 @@ public:
     void setVisible(bool isVisible);
     Utils::Id category() const { return m_category; }
 
-    Utils::optional<Utils::Theme::Color> color() const;
+    std::optional<Utils::Theme::Color> color() const;
     void setColor(const Utils::Theme::Color &color);
 
     QString defaultToolTip() const { return m_defaultToolTip; }
@@ -122,7 +123,7 @@ private:
     Priority m_priority = LowPriority;
     QIcon m_icon;
     std::function<QIcon()> m_iconProvider;
-    Utils::optional<Utils::Theme::Color> m_color;
+    std::optional<Utils::Theme::Color> m_color;
     bool m_visible = false;
     Utils::Id m_category;
     QString m_lineAnnotation;
diff --git a/src/plugins/updateinfo/updateinfoplugin.cpp b/src/plugins/updateinfo/updateinfoplugin.cpp
index d2047ba07a..f6e80f5799 100644
--- a/src/plugins/updateinfo/updateinfoplugin.cpp
+++ b/src/plugins/updateinfo/updateinfoplugin.cpp
@@ -271,7 +271,7 @@ void UpdateInfoPlugin::checkForUpdatesFinished()
                                << "prerelease:" << p.isPrerelease;
         }
     }
-    Utils::optional<QtPackage> qtToNag = qtToNagAbout(qtPackages, &d->m_lastMaxQtVersion);
+    std::optional<QtPackage> qtToNag = qtToNagAbout(qtPackages, &d->m_lastMaxQtVersion);
 
     if (!updates.isEmpty() || qtToNag) {
         // progress details are shown until user interaction for the "no updates" case,
diff --git a/src/plugins/updateinfo/updateinfotools.h b/src/plugins/updateinfo/updateinfotools.h
index a5c3a816ee..1f79e366b6 100644
--- a/src/plugins/updateinfo/updateinfotools.h
+++ b/src/plugins/updateinfo/updateinfotools.h
@@ -4,7 +4,6 @@
 #pragma once
 
 #include <utils/algorithm.h>
-#include <utils/optional.h>
 
 #include <QDomDocument>
 #include <QList>
@@ -12,6 +11,8 @@
 #include <QRegularExpression>
 #include <QVersionNumber>
 
+#include <optional>
+
 Q_DECLARE_LOGGING_CATEGORY(updateLog)
 
 struct Update
@@ -90,7 +91,7 @@ QList<QtPackage> availableQtPackages(const QString &packageXml)
 }
 
 // Expects packages to be sorted, high version first.
-Utils::optional<QtPackage> highestInstalledQt(const QList<QtPackage> &packages)
+std::optional<QtPackage> highestInstalledQt(const QList<QtPackage> &packages)
 {
     const auto highestInstalledIt = std::find_if(packages.cbegin(),
                                                  packages.cend(),
@@ -101,7 +102,7 @@ Utils::optional<QtPackage> highestInstalledQt(const QList<QtPackage> &packages)
 }
 
 // Expects packages to be sorted, high version first.
-Utils::optional<QtPackage> qtToNagAbout(const QList<QtPackage> &allPackages,
+std::optional<QtPackage> qtToNagAbout(const QList<QtPackage> &allPackages,
                                         QVersionNumber *highestSeen)
 {
     // Filter out any Qt prereleases
@@ -119,7 +120,7 @@ Utils::optional<QtPackage> qtToNagAbout(const QList<QtPackage> &allPackages,
         *highestSeen = highest.version;
     if (!isNew)
         return {};
-    const Utils::optional<QtPackage> highestInstalled = highestInstalledQt(packages);
+    const std::optional<QtPackage> highestInstalled = highestInstalledQt(packages);
     qCDebug(updateLog) << "Highest installed Qt:"
                        << qPrintable(highestInstalled ? highestInstalled->version.toString()
                                                       : QString("none"));
diff --git a/tests/auto/algorithm/tst_algorithm.cpp b/tests/auto/algorithm/tst_algorithm.cpp
index f18dacfb09..9eabd58557 100644
--- a/tests/auto/algorithm/tst_algorithm.cpp
+++ b/tests/auto/algorithm/tst_algorithm.cpp
@@ -532,22 +532,22 @@ void tst_Algorithm::take()
 {
     {
         QList<Struct> v {1, 3, 5, 6, 7, 8, 9, 11, 13, 15, 13, 16, 17};
-        Utils::optional<Struct> r1 = Utils::take(v, [](const Struct &s) { return s.member == 13; });
+        std::optional<Struct> r1 = Utils::take(v, [](const Struct &s) { return s.member == 13; });
         QVERIFY(static_cast<bool>(r1));
         QCOMPARE(r1.value().member, 13);
-        Utils::optional<Struct> r2 = Utils::take(v, [](const Struct &s) { return s.member == 13; });
+        std::optional<Struct> r2 = Utils::take(v, [](const Struct &s) { return s.member == 13; });
         QVERIFY(static_cast<bool>(r2));
         QCOMPARE(r2.value().member, 13);
-        Utils::optional<Struct> r3 = Utils::take(v, [](const Struct &s) { return s.member == 13; });
+        std::optional<Struct> r3 = Utils::take(v, [](const Struct &s) { return s.member == 13; });
         QVERIFY(!static_cast<bool>(r3));
 
-        Utils::optional<Struct> r4 = Utils::take(v, &Struct::isEven);
+        std::optional<Struct> r4 = Utils::take(v, &Struct::isEven);
         QVERIFY(static_cast<bool>(r4));
         QCOMPARE(r4.value().member, 6);
     }
     {
         QList<Struct> v {0, 0, 0, 0, 0, 0, 1, 2, 3};
-        Utils::optional<Struct> r1 = Utils::take(v, &Struct::member);
+        std::optional<Struct> r1 = Utils::take(v, &Struct::member);
         QVERIFY(static_cast<bool>(r1));
         QCOMPARE(r1.value().member, 1);
     }
diff --git a/tests/auto/pointeralgorithm/tst_pointeralgorithm.cpp b/tests/auto/pointeralgorithm/tst_pointeralgorithm.cpp
index 761d752b2a..43f28c2de9 100644
--- a/tests/auto/pointeralgorithm/tst_pointeralgorithm.cpp
+++ b/tests/auto/pointeralgorithm/tst_pointeralgorithm.cpp
@@ -272,8 +272,8 @@ void tst_PointerAlgorithm::take()
         int foo = 42;
 
         QVERIFY(Utils::take(vector, ptrVector.at(0)).value().get() == ptrVector.at(0));
-        QVERIFY(Utils::take(vector, ptrVector.at(0)) == Utils::nullopt);
-        QVERIFY(Utils::take(vector, &foo) == Utils::nullopt);
+        QVERIFY(Utils::take(vector, ptrVector.at(0)) == std::nullopt);
+        QVERIFY(Utils::take(vector, &foo) == std::nullopt);
         QVERIFY(Utils::take(vector, nullptr).value().get() == nullptr);
     }
 }
diff --git a/tests/auto/utils/settings/tst_settings.cpp b/tests/auto/utils/settings/tst_settings.cpp
index 83ac371f65..34b9d52bf3 100644
--- a/tests/auto/utils/settings/tst_settings.cpp
+++ b/tests/auto/utils/settings/tst_settings.cpp
@@ -80,13 +80,13 @@ protected:
             return qMakePair(key, main);
 
         if (main.isNull() && secondary.isNull())
-            return nullopt;
+            return std::nullopt;
         if (!main.isNull())
             return qMakePair(key, main);
         return qMakePair(key, secondary);
     }
 
-    Utils::optional<Issue> writeFile(const Utils::FilePath &path, const QVariantMap &data) const override
+    std::optional<Issue> writeFile(const Utils::FilePath &path, const QVariantMap &data) const override
     {
         if (data.isEmpty()) {
             return Issue(QCoreApplication::translate("Utils::SettingsAccessor", "Failed to Write File"),
@@ -95,7 +95,7 @@ protected:
         }
 
         addFile(path, data);
-        return nullopt;
+        return std::nullopt;
     }
 
 private:
@@ -582,7 +582,7 @@ void tst_SettingsAccessor::findIssues_ok()
     const QVariantMap data = versionedMap(6, TESTACCESSOR_DEFAULT_ID);
     const Utils::FilePath path = "/foo/baz.user";
 
-    const Utils::optional<Utils::SettingsAccessor::Issue> info = accessor.findIssues(data, path);
+    const std::optional<Utils::SettingsAccessor::Issue> info = accessor.findIssues(data, path);
 
     QVERIFY(!info);
 }
@@ -593,7 +593,7 @@ void tst_SettingsAccessor::findIssues_emptyData()
     const QVariantMap data;
     const Utils::FilePath path = "/foo/bar.user";
 
-    const Utils::optional<Utils::SettingsAccessor::Issue> info = accessor.findIssues(data, path);
+    const std::optional<Utils::SettingsAccessor::Issue> info = accessor.findIssues(data, path);
 
     QVERIFY(bool(info));
 }
@@ -604,7 +604,7 @@ void tst_SettingsAccessor::findIssues_tooNew()
     const QVariantMap data = versionedMap(42, TESTACCESSOR_DEFAULT_ID);
     const Utils::FilePath path = "/foo/bar.user";
 
-    const Utils::optional<Utils::SettingsAccessor::Issue> info = accessor.findIssues(data, path);
+    const std::optional<Utils::SettingsAccessor::Issue> info = accessor.findIssues(data, path);
 
     QVERIFY(bool(info));
 }
@@ -615,7 +615,7 @@ void tst_SettingsAccessor::findIssues_tooOld()
     const QVariantMap data = versionedMap(2, TESTACCESSOR_DEFAULT_ID);
     const Utils::FilePath path = "/foo/bar.user";
 
-    const Utils::optional<Utils::SettingsAccessor::Issue> info = accessor.findIssues(data, path);
+    const std::optional<Utils::SettingsAccessor::Issue> info = accessor.findIssues(data, path);
 
     QVERIFY(bool(info));
 }
@@ -626,7 +626,7 @@ void tst_SettingsAccessor::findIssues_wrongId()
     const QVariantMap data = versionedMap(6, "foo");
     const Utils::FilePath path = "/foo/bar.user";
 
-    const Utils::optional<Utils::SettingsAccessor::Issue> info = accessor.findIssues(data, path);
+    const std::optional<Utils::SettingsAccessor::Issue> info = accessor.findIssues(data, path);
 
     QVERIFY(bool(info));
 }
@@ -637,7 +637,7 @@ void tst_SettingsAccessor::findIssues_nonDefaultPath()
     const QVariantMap data = versionedMap(6, TESTACCESSOR_DEFAULT_ID);
     const Utils::FilePath path = "/foo/bar.user.foobar";
 
-    const Utils::optional<Utils::SettingsAccessor::Issue> info = accessor.findIssues(data, path);
+    const std::optional<Utils::SettingsAccessor::Issue> info = accessor.findIssues(data, path);
 
     QVERIFY(bool(info));
 }
diff --git a/tests/unit/unittest/gtest-creator-printing.h b/tests/unit/unittest/gtest-creator-printing.h
index 9a4da6fb44..cc8f82355f 100644
--- a/tests/unit/unittest/gtest-creator-printing.h
+++ b/tests/unit/unittest/gtest-creator-printing.h
@@ -4,12 +4,12 @@
 #pragma once
 
 #include <utils/cpplanguage_details.h>
-#include <utils/optional.h>
 #include <utils/smallstringio.h>
 
 #include <QtGlobal>
 
 #include <iosfwd>
+#include <optional>
 #include <variant>
 
 #include <gtest/gtest-printers.h>
@@ -79,7 +79,7 @@ std::ostream &operator<<(std::ostream &out, const Utils::LanguageExtension &lang
 std::ostream &operator<<(std::ostream &out, const FilePath &filePath);
 
 template<typename Type>
-std::ostream &operator<<(std::ostream &out, const optional<Type> &optional)
+std::ostream &operator<<(std::ostream &out, const std::optional<Type> &optional)
 {
     if (optional)
         return out << "optional " << optional.value();
@@ -88,7 +88,7 @@ std::ostream &operator<<(std::ostream &out, const optional<Type> &optional)
 }
 
 template<typename Type>
-void PrintTo(const optional<Type> &optional, ::std::ostream *os)
+void PrintTo(const std::optional<Type> &optional, ::std::ostream *os)
 {
     *os << optional;
 }
diff --git a/tests/unit/unittest/imagecachestorage-test.cpp b/tests/unit/unittest/imagecachestorage-test.cpp
index 775d397e47..1e89206247 100644
--- a/tests/unit/unittest/imagecachestorage-test.cpp
+++ b/tests/unit/unittest/imagecachestorage-test.cpp
@@ -284,7 +284,7 @@ TEST_F(ImageCacheStorageSlowTest, FetchNonExistingImageIsEmpty)
 {
     auto image = storage.fetchImage("/path/to/component", {123});
 
-    ASSERT_THAT(image, Eq(Utils::nullopt));
+    ASSERT_THAT(image, Eq(std::nullopt));
 }
 
 TEST_F(ImageCacheStorageSlowTest, FetchSameTimeImage)
@@ -302,7 +302,7 @@ TEST_F(ImageCacheStorageSlowTest, DoNotFetchOlderImage)
 
     auto image = storage.fetchImage("/path/to/component", {124});
 
-    ASSERT_THAT(image, Eq(Utils::nullopt));
+    ASSERT_THAT(image, Eq(std::nullopt));
 }
 
 TEST_F(ImageCacheStorageSlowTest, FetchNewerImage)
@@ -318,7 +318,7 @@ TEST_F(ImageCacheStorageSlowTest, FetchNonExistingSmallImageIsEmpty)
 {
     auto image = storage.fetchSmallImage("/path/to/component", {123});
 
-    ASSERT_THAT(image, Eq(Utils::nullopt));
+    ASSERT_THAT(image, Eq(std::nullopt));
 }
 
 TEST_F(ImageCacheStorageSlowTest, FetchSameTimeSmallImage)
@@ -336,7 +336,7 @@ TEST_F(ImageCacheStorageSlowTest, DoNotFetchOlderSmallImage)
 
     auto image = storage.fetchSmallImage("/path/to/component", {124});
 
-    ASSERT_THAT(image, Eq(Utils::nullopt));
+    ASSERT_THAT(image, Eq(std::nullopt));
 }
 
 TEST_F(ImageCacheStorageSlowTest, FetchNewerSmallImage)
@@ -375,7 +375,7 @@ TEST_F(ImageCacheStorageSlowTest, FetchNonExistingIconIsEmpty)
 {
     auto image = storage.fetchIcon("/path/to/component", {123});
 
-    ASSERT_THAT(image, Eq(Utils::nullopt));
+    ASSERT_THAT(image, Eq(std::nullopt));
 }
 
 TEST_F(ImageCacheStorageSlowTest, FetchSameTimeIcon)
@@ -393,7 +393,7 @@ TEST_F(ImageCacheStorageSlowTest, DoNotFetchOlderIcon)
 
     auto image = storage.fetchIcon("/path/to/component", {124});
 
-    ASSERT_THAT(image, Eq(Utils::nullopt));
+    ASSERT_THAT(image, Eq(std::nullopt));
 }
 
 TEST_F(ImageCacheStorageSlowTest, FetchNewerIcon)
diff --git a/tests/unit/unittest/projectstorage-test.cpp b/tests/unit/unittest/projectstorage-test.cpp
index ebfff84034..317d6f983d 100644
--- a/tests/unit/unittest/projectstorage-test.cpp
+++ b/tests/unit/unittest/projectstorage-test.cpp
@@ -6295,7 +6295,7 @@ TEST_F(ProjectStorage, GetInvalidOptionalPropertyDeclarationForInvalidPropertyDe
 
     auto property = storage.propertyDeclaration(PropertyDeclarationId{});
 
-    ASSERT_THAT(property, Eq(Utils::nullopt));
+    ASSERT_THAT(property, Eq(std::nullopt));
 }
 
 TEST_F(ProjectStorage, GetSignalDeclarationNames)
@@ -6603,7 +6603,7 @@ TEST_F(ProjectStorage, DontGetTypeForInvalidId)
 
     auto type = storage.type(TypeId());
 
-    ASSERT_THAT(type, Eq(Utils::nullopt));
+    ASSERT_THAT(type, Eq(std::nullopt));
 }
 
 TEST_F(ProjectStorage, GetCommonType)
diff --git a/tests/unit/unittest/sqlitereadstatementmock.h b/tests/unit/unittest/sqlitereadstatementmock.h
index 3967df0ae9..7dbb1df330 100644
--- a/tests/unit/unittest/sqlitereadstatementmock.h
+++ b/tests/unit/unittest/sqlitereadstatementmock.h
@@ -11,12 +11,12 @@
 #include <projectstorageids.h>
 #include <sqliteblob.h>
 #include <sqlitetimestamp.h>
-#include <utils/optional.h>
 #include <utils/smallstring.h>
 
 #include <QImage>
 
 #include <cstdint>
+#include <optional>
 #include <tuple>
 #include <vector>
 
@@ -33,25 +33,25 @@ public:
     MOCK_METHOD(std::vector<Utils::SmallString>, valuesReturnStringVector, (std::size_t), ());
 
     MOCK_METHOD(std::vector<long long>, valuesReturnRowIds, (std::size_t), ());
-    MOCK_METHOD(Utils::optional<long long>, valueReturnInt64, (), ());
-    MOCK_METHOD(Utils::optional<Sqlite::ByteArrayBlob>,
+    MOCK_METHOD(std::optional<long long>, valueReturnInt64, (), ());
+    MOCK_METHOD(std::optional<Sqlite::ByteArrayBlob>,
                 valueReturnBlob,
                 (Utils::SmallStringView, long long),
                 ());
 
-    MOCK_METHOD(Utils::optional<int>, valueReturnInt32, (Utils::SmallStringView), ());
+    MOCK_METHOD(std::optional<int>, valueReturnInt32, (Utils::SmallStringView), ());
 
-    MOCK_METHOD(Utils::optional<int>, valueReturnInt32, (int, Utils::SmallStringView), ());
+    MOCK_METHOD(std::optional<int>, valueReturnInt32, (int, Utils::SmallStringView), ());
 
-    MOCK_METHOD(Utils::optional<int>, valueReturnInt32, (int), ());
+    MOCK_METHOD(std::optional<int>, valueReturnInt32, (int), ());
 
-    MOCK_METHOD(Utils::optional<long long>, valueReturnInt64, (int), ());
+    MOCK_METHOD(std::optional<long long>, valueReturnInt64, (int), ());
 
-    MOCK_METHOD(Utils::optional<Utils::PathString>, valueReturnPathString, (int), ());
+    MOCK_METHOD(std::optional<Utils::PathString>, valueReturnPathString, (int), ());
 
-    MOCK_METHOD(Utils::optional<Utils::PathString>, valueReturnPathString, (Utils::SmallStringView), ());
+    MOCK_METHOD(std::optional<Utils::PathString>, valueReturnPathString, (Utils::SmallStringView), ());
 
-    MOCK_METHOD(Utils::optional<Utils::SmallString>, valueReturnSmallString, (int), ());
+    MOCK_METHOD(std::optional<Utils::SmallString>, valueReturnSmallString, (int), ());
 
     MOCK_METHOD(QmlDesigner::TypeId, valueReturnsTypeId, (long long, Utils::SmallStringView name), ());
     MOCK_METHOD(QmlDesigner::TypeId, valueWithTransactionReturnsTypeId, (long long, long long), ());
diff --git a/tests/unit/unittest/sqlitereadwritestatementmock.h b/tests/unit/unittest/sqlitereadwritestatementmock.h
index 75ea936fef..2f00f303f6 100644
--- a/tests/unit/unittest/sqlitereadwritestatementmock.h
+++ b/tests/unit/unittest/sqlitereadwritestatementmock.h
@@ -8,10 +8,10 @@
 #include <projectstorageids.h>
 
 #include <sqlite/sqlitevalue.h>
-#include <utils/optional.h>
 #include <utils/smallstring.h>
 
 #include <cstdint>
+#include <optional>
 #include <tuple>
 #include <vector>
author	Eike Ziller <eike.ziller@qt.io>	2022-08-26 10:30:00 +0200
committer	Eike Ziller <eike.ziller@qt.io>	2022-09-01 06:58:04 +0000
commit	04e50438eb85c1b2be6d4dcdfd5319cdb55ae576 (patch)
tree	4a3e9f078730bb538e2ca2751d189ff14a89901e
parent	34a9491a08639f8df0b55d74d51f4dadaa1cc2fd (diff)