[libc++][NFC] Enable modernize-use-override

[Mordante]

Nice improvement! Looking at the UBSAN CI failures there are more overrides to be added.
Can you add an NFC to the title of the patch?

libcxx/include/__memory/shared_ptr.h

134

Just curious did you use -fix for clang-tidy?

libcxx/include/codecvt

216–228

Did the indention change?

248–259

Did the indention change?

283–294

Did the indention change?

317–328

Did the indention change?

351–362

Did the indention change?

385–396

Did the indention change? Please also validate similar changes.

[philnik]

• Add a few more overrides

[philnik]

• Try to fix CI

libcxx/include/__memory/shared_ptr.h

134

Kind-of. I went trough the errors and let my IDE auto-fix them. Using -fix doesn't work very well because we copy the headers around.

libcxx/include/codecvt

216–228

The return type also doesn't have it's own line anymore. That's why the diff looks so weird.

248–259

It changed the same as the last one.

283–294

Same

317–328

same

351–362

same

385–396

same

[Mordante]

LGTM!

libcxx/.clang-tidy

 InheritParentConfig: true
 Checks: >
   bugprone-copy-constructor-init,
   bugprone-dangling-handle,
   bugprone-infinite-loop,
 
   -llvm-else-after-return,
   -llvm-header-guard,
   -llvm-qualified-auto,
 
   -misc-unconventional-assign-operator,
 
   modernize-loop-convert,
   modernize-redundant-void-arg,
+  modernize-use-override,
 
   readability-duplicate-include,
   readability-function-cognitive-complexity,
   readability-function-size,
   -readability-identifier-naming,
   readability-misplaced-array-index,
   readability-redundant-control-flow,
   readability-redundant-function-ptr-dereference,

 # bugprone-branch-clone,
 # bugprone-macro-parentheses,
 # cppcoreguidelines-prefer-member-initializer,
 # modernize-use-bool-literals,
 # modernize-use-default-member-init,
 # modernize-use-equals-default,
 # modernize-use-equals-delete,
 # modernize-use-nullptr,
-# modernize-use-override,
 # portability-restrict-system-includes,
 # readability-function-cognitive-complexity,
 # readability-implicit-bool-conversion,
 # readability-isolate-declaration,
 # readability-redundant-access-specifiers,
 # readability-redundant-declaration,
 # readability-redundant-member-init,
 # readability-simplify-boolean-expr,

libcxx/include/__debug

 
 template <class _Cont>
 struct _C_node
     : public __c_node
 {
     explicit _C_node(void* __c, __c_node* __n)
         : __c_node(__c, __n) {}
 
-    virtual bool __dereferenceable(const void*) const;
-    virtual bool __decrementable(const void*) const;
-    virtual bool __addable(const void*, ptrdiff_t) const;
-    virtual bool __subscriptable(const void*, ptrdiff_t) const;
+    bool __dereferenceable(const void*) const override;
+    bool __decrementable(const void*) const override;
+    bool __addable(const void*, ptrdiff_t) const override;
+    bool __subscriptable(const void*, ptrdiff_t) const override;
 };
 
 template <class _Cont>
 inline bool
 _C_node<_Cont>::__dereferenceable(const void* __i) const
 {
     typedef typename _Cont::const_iterator iterator;
     const iterator* __j = static_cast<const iterator*>(__i);

libcxx/include/__format/format_error.h

 #if _LIBCPP_STD_VER > 17
 
 class _LIBCPP_EXCEPTION_ABI format_error : public runtime_error {
 public:
   _LIBCPP_HIDE_FROM_ABI explicit format_error(const string& __s)
       : runtime_error(__s) {}
   _LIBCPP_HIDE_FROM_ABI explicit format_error(const char* __s)
       : runtime_error(__s) {}
-  virtual ~format_error() noexcept;
+  ~format_error() noexcept override;
 };
 
 _LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void
 __throw_format_error(const char* __s) {
 #ifndef _LIBCPP_NO_EXCEPTIONS
   throw format_error(__s);
 #else
   (void)__s;

libcxx/include/__functional/function.h

 class _LIBCPP_EXCEPTION_ABI bad_function_call
     : public exception
 {
 public:
 // Note that when a key function is not used, every translation unit that uses
 // bad_function_call will end up containing a weak definition of the vtable and
 // typeinfo.
 #ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION
-    virtual ~bad_function_call() _NOEXCEPT;
+    ~bad_function_call() _NOEXCEPT override;
 #else
-    virtual ~bad_function_call() _NOEXCEPT {}
+    ~bad_function_call() _NOEXCEPT override {}
 #endif
 
 #ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_GOOD_WHAT_MESSAGE
-    virtual const char* what() const _NOEXCEPT;
+    const char* what() const _NOEXCEPT override;
 #endif
 };
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_bad_function_call()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw bad_function_call();

libcxx/include/__locale

 class _LIBCPP_TYPE_VIS locale::facet
     : public __shared_count
 {
 protected:
     _LIBCPP_INLINE_VISIBILITY
     explicit facet(size_t __refs = 0)
         : __shared_count(static_cast<long>(__refs)-1) {}
 
-    virtual ~facet();
+    ~facet() override;
 
 //    facet(const facet&) = delete;     // effectively done in __shared_count
 //    void operator=(const facet&) = delete;
 private:
-    virtual void __on_zero_shared() _NOEXCEPT;
+    void __on_zero_shared() _NOEXCEPT override;
 };
 
 class _LIBCPP_TYPE_VIS locale::id
 {
     once_flag      __flag_;
     int32_t        __id_;
 
     static int32_t __next_id;
public:
     long hash(const char_type* __lo, const char_type* __hi) const
     {
         return do_hash(__lo, __hi);
     }
 
     static locale::id id;
 
 protected:
-    ~collate();
+    ~collate() override;
     virtual int do_compare(const char_type* __lo1, const char_type* __hi1,
                            const char_type* __lo2, const char_type* __hi2) const;
     virtual string_type do_transform(const char_type* __lo, const char_type* __hi) const
         {return string_type(__lo, __hi);}
     virtual long do_hash(const char_type* __lo, const char_type* __hi) const;
 };
 
 template <class _CharT> locale::id collate<_CharT>::id;

 public:
     typedef char char_type;
     typedef basic_string<char_type> string_type;
 
     explicit collate_byname(const char* __n, size_t __refs = 0);
     explicit collate_byname(const string& __n, size_t __refs = 0);
 
 protected:
-    ~collate_byname();
-    virtual int do_compare(const char_type* __lo1, const char_type* __hi1,
-                           const char_type* __lo2, const char_type* __hi2) const;
-    virtual string_type do_transform(const char_type* __lo, const char_type* __hi) const;
+    ~collate_byname() override;
+    int do_compare(const char_type* __lo1, const char_type* __hi1,
+                   const char_type* __lo2, const char_type* __hi2) const override;
+    string_type do_transform(const char_type* __lo, const char_type* __hi) const override;
 };
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>
 class _LIBCPP_TYPE_VIS collate_byname<wchar_t>
     : public collate<wchar_t>
 {
     locale_t __l;
 public:
     typedef wchar_t char_type;
     typedef basic_string<char_type> string_type;
 
     explicit collate_byname(const char* __n, size_t __refs = 0);
     explicit collate_byname(const string& __n, size_t __refs = 0);
 
 protected:
-    ~collate_byname();
+    ~collate_byname() override;
 
-    virtual int do_compare(const char_type* __lo1, const char_type* __hi1,
-                           const char_type* __lo2, const char_type* __hi2) const;
-    virtual string_type do_transform(const char_type* __lo, const char_type* __hi) const;
+    int do_compare(const char_type* __lo1, const char_type* __hi1,
+                   const char_type* __lo2, const char_type* __hi2) const override;
+    string_type do_transform(const char_type* __lo, const char_type* __hi) const override;
 };
 #endif
 
 template <class _CharT, class _Traits, class _Allocator>
 bool
 locale::operator()(const basic_string<_CharT, _Traits, _Allocator>& __x,
                    const basic_string<_CharT, _Traits, _Allocator>& __y) const
 {
public:
     const char_type* narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const
     {
         return do_narrow(__low, __high, __dfault, __to);
     }
 
     static locale::id id;
 
 protected:
-    ~ctype();
+    ~ctype() override;
     virtual bool do_is(mask __m, char_type __c) const;
     virtual const char_type* do_is(const char_type* __low, const char_type* __high, mask* __vec) const;
     virtual const char_type* do_scan_is(mask __m, const char_type* __low, const char_type* __high) const;
     virtual const char_type* do_scan_not(mask __m, const char_type* __low, const char_type* __high) const;
     virtual char_type do_toupper(char_type) const;
     virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const;
     virtual char_type do_tolower(char_type) const;
     virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const;
#if defined(__NetBSD__)
     static const short* __classic_lower_table() _NOEXCEPT;
 #endif
 #if defined(__MVS__)
     static const unsigned short* __classic_upper_table() _NOEXCEPT;
     static const unsigned short* __classic_lower_table() _NOEXCEPT;
 #endif
 
 protected:
-    ~ctype();
+    ~ctype() override;
     virtual char_type do_toupper(char_type __c) const;
     virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const;
     virtual char_type do_tolower(char_type __c) const;
     virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const;
     virtual char_type do_widen(char __c) const;
     virtual const char* do_widen(const char* __low, const char* __high, char_type* __to) const;
     virtual char do_narrow(char_type __c, char __dfault) const;
     virtual const char* do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const;

 {
     locale_t __l;
 
 public:
     explicit ctype_byname(const char*, size_t = 0);
     explicit ctype_byname(const string&, size_t = 0);
 
 protected:
-    ~ctype_byname();
-    virtual char_type do_toupper(char_type) const;
-    virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const;
-    virtual char_type do_tolower(char_type) const;
-    virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const;
+    ~ctype_byname() override;
+    char_type do_toupper(char_type) const override;
+    const char_type* do_toupper(char_type* __low, const char_type* __high) const override;
+    char_type do_tolower(char_type) const override;
+    const char_type* do_tolower(char_type* __low, const char_type* __high) const override;
 };
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>
 class _LIBCPP_TYPE_VIS ctype_byname<wchar_t>
     : public ctype<wchar_t>
 {
     locale_t __l;
 
 public:
     explicit ctype_byname(const char*, size_t = 0);
     explicit ctype_byname(const string&, size_t = 0);
 
 protected:
-    ~ctype_byname();
-    virtual bool do_is(mask __m, char_type __c) const;
-    virtual const char_type* do_is(const char_type* __low, const char_type* __high, mask* __vec) const;
-    virtual const char_type* do_scan_is(mask __m, const char_type* __low, const char_type* __high) const;
-    virtual const char_type* do_scan_not(mask __m, const char_type* __low, const char_type* __high) const;
-    virtual char_type do_toupper(char_type) const;
-    virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const;
-    virtual char_type do_tolower(char_type) const;
-    virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const;
-    virtual char_type do_widen(char) const;
-    virtual const char* do_widen(const char* __low, const char* __high, char_type* __dest) const;
-    virtual char do_narrow(char_type, char __dfault) const;
-    virtual const char_type* do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __dest) const;
+    ~ctype_byname() override;
+    bool do_is(mask __m, char_type __c) const override;
+    const char_type* do_is(const char_type* __low, const char_type* __high, mask* __vec) const override;
+    const char_type* do_scan_is(mask __m, const char_type* __low, const char_type* __high) const override;
+    const char_type* do_scan_not(mask __m, const char_type* __low, const char_type* __high) const override;
+    char_type do_toupper(char_type) const override;
+    const char_type* do_toupper(char_type* __low, const char_type* __high) const override;
+    char_type do_tolower(char_type) const override;
+    const char_type* do_tolower(char_type* __low, const char_type* __high) const override;
+    char_type do_widen(char) const override;
+    const char* do_widen(const char* __low, const char* __high, char_type* __dest) const override;
+    char do_narrow(char_type, char __dfault) const override;
+    const char_type* do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __dest) const override;
 };
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 template <class _CharT>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 isspace(_CharT __c, const locale& __loc)
 {
public:
 
     static locale::id id;
 
 protected:
     _LIBCPP_INLINE_VISIBILITY
     explicit codecvt(const char*, size_t __refs = 0)
         : locale::facet(__refs) {}
 
-    ~codecvt();
+    ~codecvt() override;
 
     virtual result do_out(state_type& __st,
                           const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                           extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result do_in(state_type& __st,
                          const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
                          intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result do_unshift(state_type& __st,
int max_length() const  _NOEXCEPT
         return do_max_length();
     }
 
     static locale::id id;
 
 protected:
     explicit codecvt(const char*, size_t __refs = 0);
 
-    ~codecvt();
+    ~codecvt() override;
 
     virtual result do_out(state_type& __st,
                           const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                           extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result do_in(state_type& __st,
                          const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
                          intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result do_unshift(state_type& __st,
public:
 
     static locale::id id;
 
 protected:
     _LIBCPP_INLINE_VISIBILITY
     explicit codecvt(const char*, size_t __refs = 0)
         : locale::facet(__refs) {}
 
-    ~codecvt();
+    ~codecvt() override;
 
     virtual result do_out(state_type& __st,
                           const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                           extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result do_in(state_type& __st,
                          const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
                          intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result do_unshift(state_type& __st,
public:
 
     static locale::id id;
 
 protected:
     _LIBCPP_INLINE_VISIBILITY
     explicit codecvt(const char*, size_t __refs = 0)
         : locale::facet(__refs) {}
 
-    ~codecvt();
+    ~codecvt() override;
 
     virtual result do_out(state_type& __st,
                           const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                           extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result do_in(state_type& __st,
                          const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
                          intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result do_unshift(state_type& __st,
public:
 
     static locale::id id;
 
 protected:
     _LIBCPP_INLINE_VISIBILITY
     explicit codecvt(const char*, size_t __refs = 0)
         : locale::facet(__refs) {}
 
-    ~codecvt();
+    ~codecvt() override;
 
     virtual result do_out(state_type& __st,
                           const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                           extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result do_in(state_type& __st,
                          const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
                          intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result do_unshift(state_type& __st,
public:
 
     static locale::id id;
 
 protected:
     _LIBCPP_INLINE_VISIBILITY
     explicit codecvt(const char*, size_t __refs = 0)
         : locale::facet(__refs) {}
 
-    ~codecvt();
+    ~codecvt() override;
 
     virtual result do_out(state_type& __st,
                           const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                           extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result do_in(state_type& __st,
                          const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
                          intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result do_unshift(state_type& __st,

 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit codecvt_byname(const char* __nm, size_t __refs = 0)
         : codecvt<_InternT, _ExternT, _StateT>(__nm, __refs) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit codecvt_byname(const string& __nm, size_t __refs = 0)
         : codecvt<_InternT, _ExternT, _StateT>(__nm.c_str(), __refs) {}
 protected:
-    ~codecvt_byname();
+    ~codecvt_byname() override;
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _InternT, class _ExternT, class _StateT>
 codecvt_byname<_InternT, _ExternT, _StateT>::~codecvt_byname()
 {
 }
 _LIBCPP_SUPPRESS_DEPRECATED_POP

 template <>
 struct _LIBCPP_TYPE_VIS __narrow_to_utf8<16>
     : public codecvt<char16_t, char, mbstate_t>
 {
     _LIBCPP_INLINE_VISIBILITY
     __narrow_to_utf8() : codecvt<char16_t, char, mbstate_t>(1) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
-    ~__narrow_to_utf8();
+    ~__narrow_to_utf8() override;
 
     template <class _OutputIterator, class _CharT>
     _LIBCPP_INLINE_VISIBILITY
     _OutputIterator
     operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const
     {
         result __r = ok;
         mbstate_t __mb;

 template <>
 struct _LIBCPP_TYPE_VIS __narrow_to_utf8<32>
     : public codecvt<char32_t, char, mbstate_t>
 {
     _LIBCPP_INLINE_VISIBILITY
     __narrow_to_utf8() : codecvt<char32_t, char, mbstate_t>(1) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
-    ~__narrow_to_utf8();
+    ~__narrow_to_utf8() override;
 
     template <class _OutputIterator, class _CharT>
     _LIBCPP_INLINE_VISIBILITY
     _OutputIterator
     operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const
     {
         result __r = ok;
         mbstate_t __mb;

 template <>
 struct _LIBCPP_TYPE_VIS __widen_from_utf8<16>
     : public codecvt<char16_t, char, mbstate_t>
 {
     _LIBCPP_INLINE_VISIBILITY
     __widen_from_utf8() : codecvt<char16_t, char, mbstate_t>(1) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
-    ~__widen_from_utf8();
+    ~__widen_from_utf8() override;
 
     template <class _OutputIterator>
     _LIBCPP_INLINE_VISIBILITY
     _OutputIterator
     operator()(_OutputIterator __s, const char* __nb, const char* __ne) const
     {
         result __r = ok;
         mbstate_t __mb;

 template <>
 struct _LIBCPP_TYPE_VIS __widen_from_utf8<32>
     : public codecvt<char32_t, char, mbstate_t>
 {
     _LIBCPP_INLINE_VISIBILITY
     __widen_from_utf8() : codecvt<char32_t, char, mbstate_t>(1) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
-    ~__widen_from_utf8();
+    ~__widen_from_utf8() override;
 
     template <class _OutputIterator>
     _LIBCPP_INLINE_VISIBILITY
     _OutputIterator
     operator()(_OutputIterator __s, const char* __nb, const char* __ne) const
     {
         result __r = ok;
         mbstate_t __mb;
public:
     _LIBCPP_INLINE_VISIBILITY char_type thousands_sep() const {return do_thousands_sep();}
     _LIBCPP_INLINE_VISIBILITY string grouping() const         {return do_grouping();}
     _LIBCPP_INLINE_VISIBILITY string_type truename() const    {return do_truename();}
     _LIBCPP_INLINE_VISIBILITY string_type falsename() const   {return do_falsename();}
 
     static locale::id id;
 
 protected:
-    ~numpunct();
+    ~numpunct() override;
     virtual char_type do_decimal_point() const;
     virtual char_type do_thousands_sep() const;
     virtual string do_grouping() const;
     virtual string_type do_truename() const;
     virtual string_type do_falsename() const;
 
     char_type __decimal_point_;
     char_type __thousands_sep_;
public:
     _LIBCPP_INLINE_VISIBILITY char_type thousands_sep() const {return do_thousands_sep();}
     _LIBCPP_INLINE_VISIBILITY string grouping() const         {return do_grouping();}
     _LIBCPP_INLINE_VISIBILITY string_type truename() const    {return do_truename();}
     _LIBCPP_INLINE_VISIBILITY string_type falsename() const   {return do_falsename();}
 
     static locale::id id;
 
 protected:
-    ~numpunct();
+    ~numpunct() override;
     virtual char_type do_decimal_point() const;
     virtual char_type do_thousands_sep() const;
     virtual string do_grouping() const;
     virtual string_type do_truename() const;
     virtual string_type do_falsename() const;
 
     char_type __decimal_point_;
     char_type __thousands_sep_;

 public:
     typedef char char_type;
     typedef basic_string<char_type> string_type;
 
     explicit numpunct_byname(const char* __nm, size_t __refs = 0);
     explicit numpunct_byname(const string& __nm, size_t __refs = 0);
 
 protected:
-    ~numpunct_byname();
+    ~numpunct_byname() override;
 
 private:
     void __init(const char*);
 };
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>
 class _LIBCPP_TYPE_VIS numpunct_byname<wchar_t>
 : public numpunct<wchar_t>
 {
 public:
     typedef wchar_t char_type;
     typedef basic_string<char_type> string_type;
 
     explicit numpunct_byname(const char* __nm, size_t __refs = 0);
     explicit numpunct_byname(const string& __nm, size_t __refs = 0);
 
 protected:
-    ~numpunct_byname();
+    ~numpunct_byname() override;
 
 private:
     void __init(const char*);
 };
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___LOCALE

libcxx/include/__memory/shared_ptr.h

 }
 
 class _LIBCPP_EXCEPTION_ABI bad_weak_ptr
     : public std::exception
 {
 public:
     bad_weak_ptr() _NOEXCEPT = default;
     bad_weak_ptr(const bad_weak_ptr&) _NOEXCEPT = default;
-    virtual ~bad_weak_ptr() _NOEXCEPT;
-    virtual const char* what() const  _NOEXCEPT;
+    ~bad_weak_ptr() _NOEXCEPT override;
+     const char* what() const  _NOEXCEPT override;
 };
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_bad_weak_ptr()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw bad_weak_ptr();
 #else
class _LIBCPP_TYPE_VIS __shared_weak_count
     long __shared_weak_owners_;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit __shared_weak_count(long __refs = 0) _NOEXCEPT
         : __shared_count(__refs),
           __shared_weak_owners_(__refs) {}
 protected:
-    virtual ~__shared_weak_count();
+    ~__shared_weak_count() override;
 
 public:
 #if defined(_LIBCPP_SHARED_PTR_DEFINE_LEGACY_INLINE_FUNCTIONS)
     void __add_shared() noexcept;
     void __add_weak() noexcept;
     void __release_shared() noexcept;
 #else
     _LIBCPP_INLINE_VISIBILITY

 {
     __compressed_pair<__compressed_pair<_Tp, _Dp>, _Alloc> __data_;
 public:
     _LIBCPP_INLINE_VISIBILITY
     __shared_ptr_pointer(_Tp __p, _Dp __d, _Alloc __a)
         :  __data_(__compressed_pair<_Tp, _Dp>(__p, _VSTD::move(__d)), _VSTD::move(__a)) {}
 
 #ifndef _LIBCPP_NO_RTTI
-    virtual const void* __get_deleter(const type_info&) const _NOEXCEPT;
+    const void* __get_deleter(const type_info&) const _NOEXCEPT override;
 #endif
 
 private:
-    virtual void __on_zero_shared() _NOEXCEPT;
-    virtual void __on_zero_shared_weak() _NOEXCEPT;
+    void __on_zero_shared() _NOEXCEPT override;
+    void __on_zero_shared_weak() _NOEXCEPT override;
 };
 
 #ifndef _LIBCPP_NO_RTTI
 
 template <class _Tp, class _Dp, class _Alloc>
 const void*
 __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__get_deleter(const type_info& __t) const _NOEXCEPT
 {
#endif
 
     _LIBCPP_HIDE_FROM_ABI
     _Alloc* __get_alloc() _NOEXCEPT { return __storage_.__get_alloc(); }
 
     _LIBCPP_HIDE_FROM_ABI
     _Tp* __get_elem() _NOEXCEPT { return __storage_.__get_elem(); }
 
 private:
-    virtual void __on_zero_shared() _NOEXCEPT {
+    void __on_zero_shared() _NOEXCEPT override {
 #if _LIBCPP_STD_VER > 17
         using _TpAlloc = typename __allocator_traits_rebind<_Alloc, _Tp>::type;
         _TpAlloc __tmp(*__get_alloc());
         allocator_traits<_TpAlloc>::destroy(__tmp, __get_elem());
 #else
         __get_elem()->~_Tp();
 #endif
     }
 
-    virtual void __on_zero_shared_weak() _NOEXCEPT {
+    void __on_zero_shared_weak() _NOEXCEPT override {
         using _ControlBlockAlloc = typename __allocator_traits_rebind<_Alloc, __shared_ptr_emplace>::type;
         using _ControlBlockPointer = typename allocator_traits<_ControlBlockAlloc>::pointer;
         _ControlBlockAlloc __tmp(*__get_alloc());
         __storage_.~_Storage();
         allocator_traits<_ControlBlockAlloc>::deallocate(__tmp,
             pointer_traits<_ControlBlockPointer>::pointer_to(*this), 1);
     }
 

libcxx/include/any

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 namespace std {
 class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_ANY_CAST bad_any_cast : public bad_cast
 {
 public:
-    virtual const char* what() const _NOEXCEPT;
+    const char* what() const _NOEXCEPT override;
 };
 } // namespace std
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY

libcxx/include/codecvt

public:
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 protected:
-    virtual result
-        do_out(state_type& __st,
+    result do_out(state_type& __st,
                   const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual result
-        do_in(state_type& __st,
-              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
-    virtual result
-        do_unshift(state_type& __st,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const _NOEXCEPT;
-    virtual bool do_always_noconv() const _NOEXCEPT;
-    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
-                          size_t __mx) const;
-    virtual int do_max_length() const _NOEXCEPT;
+                  extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+    result do_in(state_type& __st,
+                 const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+                 intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
+    result do_unshift(state_type& __st,
+                      extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+    int do_encoding() const _NOEXCEPT override;
+    bool do_always_noconv() const _NOEXCEPT override;
+    int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+    int do_max_length() const _NOEXCEPT override;
 };
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf8<char16_t>
     : public codecvt<char16_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char16_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
-    virtual result
-        do_out(state_type& __st,
+     result do_out(state_type& __st,
                    const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual result
-        do_in(state_type& __st,
-              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
-    virtual result
-        do_unshift(state_type& __st,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const _NOEXCEPT;
-    virtual bool do_always_noconv() const _NOEXCEPT;
-    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
-                          size_t __mx) const;
-    virtual int do_max_length() const _NOEXCEPT;
+                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     result do_in(state_type& __st,
+                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
+     result do_unshift(state_type& __st,
+                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     int do_encoding() const _NOEXCEPT override;
+     bool do_always_noconv() const _NOEXCEPT override;
+     int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+     int do_max_length() const _NOEXCEPT override;
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf8<char32_t>
     : public codecvt<char32_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char32_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
-    virtual result
-        do_out(state_type& __st,
+     result do_out(state_type& __st,
                    const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual result
-        do_in(state_type& __st,
-              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
-    virtual result
-        do_unshift(state_type& __st,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const _NOEXCEPT;
-    virtual bool do_always_noconv() const _NOEXCEPT;
-    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
-                          size_t __mx) const;
-    virtual int do_max_length() const _NOEXCEPT;
+                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     result do_in(state_type& __st,
+                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
+     result do_unshift(state_type& __st,
+                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     int do_encoding() const _NOEXCEPT override;
+     bool do_always_noconv() const _NOEXCEPT override;
+     int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+     int do_max_length() const _NOEXCEPT override;
 };
 
 template <class _Elem, unsigned long _Maxcode = 0x10ffff,
           codecvt_mode _Mode = (codecvt_mode)0>
 class _LIBCPP_TEMPLATE_VIS codecvt_utf8
     : public __codecvt_utf8<_Elem>
 {
 public:
public:
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 protected:
-    virtual result
-        do_out(state_type& __st,
+     result do_out(state_type& __st,
                    const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual result
-        do_in(state_type& __st,
-              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
-    virtual result
-        do_unshift(state_type& __st,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const _NOEXCEPT;
-    virtual bool do_always_noconv() const _NOEXCEPT;
-    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
-                          size_t __mx) const;
-    virtual int do_max_length() const _NOEXCEPT;
+                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     result do_in(state_type& __st,
+                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
+     result do_unshift(state_type& __st,
+                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     int do_encoding() const _NOEXCEPT override;
+     bool do_always_noconv() const _NOEXCEPT override;
+     int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
+                          size_t __mx) const override;
+     int do_max_length() const _NOEXCEPT override;
 };
 
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf16<wchar_t, true>
     : public codecvt<wchar_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef wchar_t   intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 protected:
-    virtual result
-        do_out(state_type& __st,
+     result do_out(state_type& __st,
                    const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual result
-        do_in(state_type& __st,
-              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
-    virtual result
-        do_unshift(state_type& __st,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const _NOEXCEPT;
-    virtual bool do_always_noconv() const _NOEXCEPT;
-    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
-                          size_t __mx) const;
-    virtual int do_max_length() const _NOEXCEPT;
+                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     result do_in(state_type& __st,
+                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
+     result do_unshift(state_type& __st,
+                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     int do_encoding() const _NOEXCEPT override;
+     bool do_always_noconv() const _NOEXCEPT override;
+     int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+     int do_max_length() const _NOEXCEPT override;
 };
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf16<char16_t, false>
     : public codecvt<char16_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char16_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
-    virtual result
-        do_out(state_type& __st,
+     result do_out(state_type& __st,
                    const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual result
-        do_in(state_type& __st,
-              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
-    virtual result
-        do_unshift(state_type& __st,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const _NOEXCEPT;
-    virtual bool do_always_noconv() const _NOEXCEPT;
-    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
-                          size_t __mx) const;
-    virtual int do_max_length() const _NOEXCEPT;
+                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     result do_in(state_type& __st,
+                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
+     result do_unshift(state_type& __st,
+                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     int do_encoding() const _NOEXCEPT override;
+     bool do_always_noconv() const _NOEXCEPT override;
+     int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+     int do_max_length() const _NOEXCEPT override;
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf16<char16_t, true>
     : public codecvt<char16_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char16_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
-    virtual result
-        do_out(state_type& __st,
+     result do_out(state_type& __st,
                    const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual result
-        do_in(state_type& __st,
-              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
-    virtual result
-        do_unshift(state_type& __st,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const _NOEXCEPT;
-    virtual bool do_always_noconv() const _NOEXCEPT;
-    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
-                          size_t __mx) const;
-    virtual int do_max_length() const _NOEXCEPT;
+                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     result do_in(state_type& __st,
+                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
+     result do_unshift(state_type& __st,
+                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     int do_encoding() const _NOEXCEPT override;
+     bool do_always_noconv() const _NOEXCEPT override;
+     int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+     int do_max_length() const _NOEXCEPT override;
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf16<char32_t, false>
     : public codecvt<char32_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char32_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
-    virtual result
-        do_out(state_type& __st,
+     result do_out(state_type& __st,
                    const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual result
-        do_in(state_type& __st,
-              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
-    virtual result
-        do_unshift(state_type& __st,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const _NOEXCEPT;
-    virtual bool do_always_noconv() const _NOEXCEPT;
-    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
-                          size_t __mx) const;
-    virtual int do_max_length() const _NOEXCEPT;
+                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     result do_in(state_type& __st,
+                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
+     result do_unshift(state_type& __st,
+                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     int do_encoding() const _NOEXCEPT override;
+     bool do_always_noconv() const _NOEXCEPT override;
+     int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+     int do_max_length() const _NOEXCEPT override;
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf16<char32_t, true>
     : public codecvt<char32_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char32_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
-    virtual result
-        do_out(state_type& __st,
+     result do_out(state_type& __st,
                    const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual result
-        do_in(state_type& __st,
-              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
-    virtual result
-        do_unshift(state_type& __st,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const _NOEXCEPT;
-    virtual bool do_always_noconv() const _NOEXCEPT;
-    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
-                          size_t __mx) const;
-    virtual int do_max_length() const _NOEXCEPT;
+                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     result do_in(state_type& __st,
+                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
+     result do_unshift(state_type& __st,
+                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     int do_encoding() const _NOEXCEPT override;
+     bool do_always_noconv() const _NOEXCEPT override;
+     int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+     int do_max_length() const _NOEXCEPT override;
 };
 
 template <class _Elem, unsigned long _Maxcode = 0x10ffff,
           codecvt_mode _Mode = (codecvt_mode)0>
 class _LIBCPP_TEMPLATE_VIS codecvt_utf16
     : public __codecvt_utf16<_Elem, _Mode & little_endian>
 {
 public:
public:
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 protected:
-    virtual result
-        do_out(state_type& __st,
+     result do_out(state_type& __st,
                    const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual result
-        do_in(state_type& __st,
-              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
-    virtual result
-        do_unshift(state_type& __st,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const _NOEXCEPT;
-    virtual bool do_always_noconv() const _NOEXCEPT;
-    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
-                          size_t __mx) const;
-    virtual int do_max_length() const _NOEXCEPT;
+                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     result do_in(state_type& __st,
+                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
+     result do_unshift(state_type& __st,
+                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     int do_encoding() const _NOEXCEPT override;
+     bool do_always_noconv() const _NOEXCEPT override;
+     int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+     int do_max_length() const _NOEXCEPT override;
 };
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf8_utf16<char32_t>
     : public codecvt<char32_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char32_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
-    virtual result
-        do_out(state_type& __st,
+     result do_out(state_type& __st,
                    const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual result
-        do_in(state_type& __st,
-              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
-    virtual result
-        do_unshift(state_type& __st,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const _NOEXCEPT;
-    virtual bool do_always_noconv() const _NOEXCEPT;
-    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
-                          size_t __mx) const;
-    virtual int do_max_length() const _NOEXCEPT;
+                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     result do_in(state_type& __st,
+                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
+     result do_unshift(state_type& __st,
+                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     int do_encoding() const _NOEXCEPT override;
+     bool do_always_noconv() const _NOEXCEPT override;
+     int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+     int do_max_length() const _NOEXCEPT override;
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf8_utf16<char16_t>
     : public codecvt<char16_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char16_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
-    virtual result
-        do_out(state_type& __st,
+     result do_out(state_type& __st,
                    const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual result
-        do_in(state_type& __st,
-              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
-    virtual result
-        do_unshift(state_type& __st,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const _NOEXCEPT;
-    virtual bool do_always_noconv() const _NOEXCEPT;
-    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
-                          size_t __mx) const;
-    virtual int do_max_length() const _NOEXCEPT;
+                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     result do_in(state_type& __st,
+                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
+     result do_unshift(state_type& __st,
+                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+     int do_encoding() const _NOEXCEPT override;
+     bool do_always_noconv() const _NOEXCEPT override;
+     int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+     int do_max_length() const _NOEXCEPT override;
 };
 
 template <class _Elem, unsigned long _Maxcode = 0x10ffff,
           codecvt_mode _Mode = (codecvt_mode)0>
 class _LIBCPP_TEMPLATE_VIS codecvt_utf8_utf16
     : public __codecvt_utf8_utf16<_Elem>
 {
 public:

libcxx/include/exception

public:
     virtual const char* what() const _NOEXCEPT;
 };
 
 class _LIBCPP_EXCEPTION_ABI bad_exception
     : public exception
 {
 public:
     _LIBCPP_INLINE_VISIBILITY bad_exception() _NOEXCEPT {}
-    virtual ~bad_exception() _NOEXCEPT;
-    virtual const char* what() const _NOEXCEPT;
+    ~bad_exception() _NOEXCEPT override;
+    const char* what() const _NOEXCEPT override;
 };
 #endif // !_LIBCPP_ABI_VCRUNTIME
 
 #if _LIBCPP_STD_VER <= 14 \
     || defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS) \
     || defined(_LIBCPP_BUILDING_LIBRARY)
 typedef void (*unexpected_handler)();
 _LIBCPP_FUNC_VIS unexpected_handler set_unexpected(unexpected_handler) _NOEXCEPT;

libcxx/include/experimental/memory_resource

public:
     operator=(__resource_adaptor_imp const &) = default;
 
     _LIBCPP_INLINE_VISIBILITY
     allocator_type get_allocator() const
     { return __alloc_; }
 
 // 8.7.3, memory.resource.adaptor.mem
 private:
-    virtual void * do_allocate(size_t __bytes, size_t)
+    void * do_allocate(size_t __bytes, size_t) override
     {
         if (__bytes > __max_size())
             __throw_bad_array_new_length();
         size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign;
         return __alloc_.allocate(__s);
     }
 
-    virtual void do_deallocate(void * __p, size_t __bytes, size_t)
+    void do_deallocate(void * __p, size_t __bytes, size_t) override
     {
         _LIBCPP_ASSERT(__bytes <= __max_size(),
             "do_deallocate called for size which exceeds the maximum allocation size");
         size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign;
         __alloc_.deallocate((_ValueType*)__p, __s);
     }
 
-    virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT {
+    bool do_is_equal(memory_resource const & __other) const _NOEXCEPT override {
         __resource_adaptor_imp const * __p
           = dynamic_cast<__resource_adaptor_imp const *>(&__other);
         return __p  ? __alloc_ == __p->__alloc_ : false;
     }
 
     _LIBCPP_INLINE_VISIBILITY
     size_t __max_size() const _NOEXCEPT {
         return numeric_limits<size_t>::max() - _MaxAlign;

libcxx/include/fstream

public:
     typedef typename traits_type::int_type   int_type;
     typedef typename traits_type::pos_type   pos_type;
     typedef typename traits_type::off_type   off_type;
     typedef typename traits_type::state_type state_type;
 
     // 27.9.1.2 Constructors/destructor:
     basic_filebuf();
     basic_filebuf(basic_filebuf&& __rhs);
-    virtual ~basic_filebuf();
+    ~basic_filebuf() override;
 
     // 27.9.1.3 Assign/swap:
     _LIBCPP_INLINE_VISIBILITY
     basic_filebuf& operator=(basic_filebuf&& __rhs);
     void swap(basic_filebuf& __rhs);
 
     // 27.9.1.4 Members:
     _LIBCPP_INLINE_VISIBILITY
#endif
     basic_filebuf* close();
 
     _LIBCPP_INLINE_VISIBILITY
     inline static const char*
     __make_mdstring(ios_base::openmode __mode) _NOEXCEPT;
 
   protected:
     // 27.9.1.5 Overridden virtual functions:
-    virtual int_type underflow();
-    virtual int_type pbackfail(int_type __c = traits_type::eof());
-    virtual int_type overflow (int_type __c = traits_type::eof());
-    virtual basic_streambuf<char_type, traits_type>* setbuf(char_type* __s, streamsize __n);
-    virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
-                             ios_base::openmode __wch = ios_base::in | ios_base::out);
-    virtual pos_type seekpos(pos_type __sp,
-                             ios_base::openmode __wch = ios_base::in | ios_base::out);
-    virtual int sync();
-    virtual void imbue(const locale& __loc);
+    int_type underflow() override;
+    int_type pbackfail(int_type __c = traits_type::eof()) override;
+    int_type overflow (int_type __c = traits_type::eof()) override;
+    basic_streambuf<char_type, traits_type>* setbuf(char_type* __s, streamsize __n) override;
+    pos_type seekoff(off_type __off, ios_base::seekdir __way,
+                     ios_base::openmode __wch = ios_base::in | ios_base::out) override;
+    pos_type seekpos(pos_type __sp,
+                     ios_base::openmode __wch = ios_base::in | ios_base::out) override;
+    int sync() override;
+    void imbue(const locale& __loc) override;
 
 private:
   char* __extbuf_;
   const char* __extbufnext_;
   const char* __extbufend_;
   char __extbuf_min_[8];
   size_t __ebs_;
   char_type* __intbuf_;

libcxx/include/future

class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_FUTURE_ERROR future_error
     error_code __ec_;
 public:
     future_error(error_code __ec);
 
     _LIBCPP_INLINE_VISIBILITY
     const error_code& code() const _NOEXCEPT {return __ec_;}
 
     future_error(const future_error&) _NOEXCEPT = default;
-    virtual ~future_error() _NOEXCEPT;
+    ~future_error() _NOEXCEPT override;
 };
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_NO_EXCEPTIONS
 _LIBCPP_AVAILABILITY_FUTURE_ERROR
 #endif
 void __throw_future_error(future_errc _Ev)
 {
class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE __assoc_sub_state
     : public __shared_count
 {
 protected:
     exception_ptr __exception_;
     mutable mutex __mut_;
     mutable condition_variable __cv_;
     unsigned __state_;
 
-    virtual void __on_zero_shared() _NOEXCEPT;
+    void __on_zero_shared() _NOEXCEPT override;
     void __sub_wait(unique_lock<mutex>& __lk);
 public:
     enum
     {
         __constructed = 1,
         __future_attached = 2,
         ready = 4,
         deferred = 8

 class _LIBCPP_AVAILABILITY_FUTURE _LIBCPP_HIDDEN __assoc_state
     : public __assoc_sub_state
 {
     typedef __assoc_sub_state base;
     typedef typename aligned_storage<sizeof(_Rp), alignment_of<_Rp>::value>::type _Up;
 protected:
     _Up __value_;
 
-    virtual void __on_zero_shared() _NOEXCEPT;
+    void __on_zero_shared() _NOEXCEPT override;
 public:
 
     template <class _Arg>
     void set_value(_Arg&& __arg);
 
     template <class _Arg>
     void set_value_at_thread_exit(_Arg&& __arg);
 

 class _LIBCPP_AVAILABILITY_FUTURE __assoc_state<_Rp&>
     : public __assoc_sub_state
 {
     typedef __assoc_sub_state base;
     typedef _Rp* _Up;
 protected:
     _Up __value_;
 
-    virtual void __on_zero_shared() _NOEXCEPT;
+    void __on_zero_shared() _NOEXCEPT override;
 public:
 
     void set_value(_Rp& __arg);
     void set_value_at_thread_exit(_Rp& __arg);
 
     _Rp& copy();
 };
 

 
 template <class _Alloc>
 class _LIBCPP_AVAILABILITY_FUTURE __assoc_sub_state_alloc
     : public __assoc_sub_state
 {
     typedef __assoc_sub_state base;
     _Alloc __alloc_;
 
-    virtual void __on_zero_shared() _NOEXCEPT;
+    void __on_zero_shared() _NOEXCEPT override;
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit __assoc_sub_state_alloc(const _Alloc& __a)
         : __alloc_(__a) {}
 };
 
 template <class _Alloc>
 void
class _LIBCPP_AVAILABILITY_FUTURE __deferred_assoc_state<void, _Fp>
     typedef __assoc_sub_state base;
 
     _Fp __func_;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit __deferred_assoc_state(_Fp&& __f);
 
-    virtual void __execute();
+    void __execute() override;
 };
 
 template <class _Fp>
 inline
 __deferred_assoc_state<void, _Fp>::__deferred_assoc_state(_Fp&& __f)
     : __func_(_VSTD::forward<_Fp>(__f))
 {
     this->__set_deferred();

 template <class _Fp>
 class _LIBCPP_AVAILABILITY_FUTURE __async_assoc_state<void, _Fp>
     : public __assoc_sub_state
 {
     typedef __assoc_sub_state base;
 
     _Fp __func_;
 
-    virtual void __on_zero_shared() _NOEXCEPT;
+    void __on_zero_shared() _NOEXCEPT override;
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit __async_assoc_state(_Fp&& __f);
 
-    virtual void __execute();
+    void __execute() override;
 };
 
 template <class _Fp>
 inline
 __async_assoc_state<void, _Fp>::__async_assoc_state(_Fp&& __f)
     : __func_(_VSTD::forward<_Fp>(__f))
 {
 }

libcxx/include/ios

 
 class _LIBCPP_EXCEPTION_ABI ios_base::failure
     : public system_error
 {
 public:
     explicit failure(const string& __msg, const error_code& __ec = io_errc::stream);
     explicit failure(const char* __msg, const error_code& __ec = io_errc::stream);
     failure(const failure&) _NOEXCEPT = default;
-    virtual ~failure() _NOEXCEPT;
+    ~failure() _NOEXCEPT override;
 };
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_failure(char const* __msg) {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw ios_base::failure(__msg);
 #else
     ((void)__msg);
#endif
     _LIBCPP_INLINE_VISIBILITY bool bad() const  {return ios_base::bad();}
 
     _LIBCPP_INLINE_VISIBILITY iostate exceptions() const {return ios_base::exceptions();}
     _LIBCPP_INLINE_VISIBILITY void exceptions(iostate __iostate) {ios_base::exceptions(__iostate);}
 
     // 27.5.4.1 Constructor/destructor:
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_ios(basic_streambuf<char_type,traits_type>* __sb);
-    virtual ~basic_ios();
+    ~basic_ios() override;
 
     // 27.5.4.2 Members:
     _LIBCPP_INLINE_VISIBILITY
     basic_ostream<char_type, traits_type>* tie() const;
     _LIBCPP_INLINE_VISIBILITY
     basic_ostream<char_type, traits_type>* tie(basic_ostream<char_type, traits_type>* __tiestr);
 
     _LIBCPP_INLINE_VISIBILITY

libcxx/include/istream

public:
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
 
     // 27.7.1.1.1 Constructor/destructor:
     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
     explicit basic_istream(basic_streambuf<char_type, traits_type>* __sb) : __gc_(0)
     { this->init(__sb); }
-    virtual ~basic_istream();
+    ~basic_istream() override;
 protected:
     inline _LIBCPP_INLINE_VISIBILITY
     basic_istream(basic_istream&& __rhs);
 
     // 27.7.1.1.2 Assign/swap:
     inline _LIBCPP_INLINE_VISIBILITY
     basic_istream& operator=(basic_istream&& __rhs);
 
public:
     typedef typename traits_type::off_type off_type;
 
     // constructor/destructor
     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
     explicit basic_iostream(basic_streambuf<char_type, traits_type>* __sb)
       : basic_istream<_CharT, _Traits>(__sb)
     {}
 
-    virtual ~basic_iostream();
+    ~basic_iostream() override;
 protected:
     inline _LIBCPP_INLINE_VISIBILITY
     basic_iostream(basic_iostream&& __rhs);
 
     // assign/swap
     inline _LIBCPP_INLINE_VISIBILITY
     basic_iostream& operator=(basic_iostream&& __rhs);
 

libcxx/include/locale

iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
                   ios_base::iostate& __err, void*& __v) const
     {
         return do_get(__b, __e, __iob, __err, __v);
     }
 
     static locale::id id;
 
 protected:
-    _LIBCPP_INLINE_VISIBILITY
-    ~num_get() {}
+    _LIBCPP_HIDE_FROM_ABI ~num_get() override {}
 
     template <class _Fp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
     iter_type __do_get_floating_point
                             (iter_type __b, iter_type __e, ios_base& __iob,
                              ios_base::iostate& __err, _Fp& __v) const;
 
     template <class _Signed>
iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
                   const void* __v) const
     {
         return do_put(__s, __iob, __fl, __v);
     }
 
     static locale::id id;
 
 protected:
-    _LIBCPP_INLINE_VISIBILITY
-    ~num_put() {}
+    _LIBCPP_HIDE_FROM_ABI ~num_put() override {}
 
     virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
                              bool __v) const;
     virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
                              long __v) const;
     virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
                              long long __v) const;
     virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
public:
 
     iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
                   ios_base::iostate& __err, tm* __tm,
                   const char_type* __fmtb, const char_type* __fmte) const;
 
     static locale::id id;
 
 protected:
-    _LIBCPP_INLINE_VISIBILITY
-    ~time_get() {}
+    _LIBCPP_HIDE_FROM_ABI ~time_get() override {}
 
     virtual dateorder do_date_order() const;
     virtual iter_type do_get_time(iter_type __b, iter_type __e, ios_base& __iob,
                                   ios_base::iostate& __err, tm* __tm) const;
     virtual iter_type do_get_date(iter_type __b, iter_type __e, ios_base& __iob,
                                   ios_base::iostate& __err, tm* __tm) const;
     virtual iter_type do_get_weekday(iter_type __b, iter_type __e, ios_base& __iob,
                                      ios_base::iostate& __err, tm* __tm) const;
explicit time_get_byname(const char* __nm, size_t __refs = 0)
         : time_get<_CharT, _InputIterator>(__refs),
           __time_get_storage<_CharT>(__nm) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit time_get_byname(const string& __nm, size_t __refs = 0)
         : time_get<_CharT, _InputIterator>(__refs),
           __time_get_storage<_CharT>(__nm) {}
 
 protected:
-    _LIBCPP_INLINE_VISIBILITY
-    ~time_get_byname() {}
+    _LIBCPP_HIDE_FROM_ABI ~time_get_byname() override {}
 
     _LIBCPP_INLINE_VISIBILITY
-    virtual dateorder do_date_order() const {return this->__do_date_order();}
+     dateorder do_date_order() const override {return this->__do_date_order();}
 private:
     _LIBCPP_INLINE_VISIBILITY
-    virtual const string_type* __weeks() const  {return this->__weeks_;}
+     const string_type* __weeks() const override  {return this->__weeks_;}
     _LIBCPP_INLINE_VISIBILITY
-    virtual const string_type* __months() const {return this->__months_;}
+     const string_type* __months() const override {return this->__months_;}
     _LIBCPP_INLINE_VISIBILITY
-    virtual const string_type* __am_pm() const  {return this->__am_pm_;}
+     const string_type* __am_pm() const override  {return this->__am_pm_;}
     _LIBCPP_INLINE_VISIBILITY
-    virtual const string_type& __c() const      {return this->__c_;}
+     const string_type& __c() const override      {return this->__c_;}
     _LIBCPP_INLINE_VISIBILITY
-    virtual const string_type& __r() const      {return this->__r_;}
+     const string_type& __r() const override      {return this->__r_;}
     _LIBCPP_INLINE_VISIBILITY
-    virtual const string_type& __x() const      {return this->__x_;}
+     const string_type& __x() const override      {return this->__x_;}
     _LIBCPP_INLINE_VISIBILITY
-    virtual const string_type& __X() const      {return this->__X_;}
+     const string_type& __X() const override      {return this->__X_;}
 };
 
 _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get_byname<char>)
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get_byname<wchar_t>)
 #endif
 
 class _LIBCPP_TYPE_VIS __time_put
iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
                   const tm* __tm, char __fmt, char __mod = 0) const
     {
         return do_put(__s, __iob, __fl, __tm, __fmt, __mod);
     }
 
     static locale::id id;
 
 protected:
-    _LIBCPP_INLINE_VISIBILITY
-    ~time_put() {}
+    _LIBCPP_HIDE_FROM_ABI ~time_put() override {}
     virtual iter_type do_put(iter_type __s, ios_base&, char_type, const tm* __tm,
                              char __fmt, char __mod) const;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit time_put(const char* __nm, size_t __refs)
         : locale::facet(__refs),
           __time_put(__nm) {}
     _LIBCPP_INLINE_VISIBILITY
public:
     explicit time_put_byname(const char* __nm, size_t __refs = 0)
         : time_put<_CharT, _OutputIterator>(__nm, __refs) {}
 
     _LIBCPP_INLINE_VISIBILITY
     explicit time_put_byname(const string& __nm, size_t __refs = 0)
         : time_put<_CharT, _OutputIterator>(__nm, __refs) {}
 
 protected:
-    _LIBCPP_INLINE_VISIBILITY
-    ~time_put_byname() {}
+    _LIBCPP_HIDE_FROM_ABI ~time_put_byname() override {}
 };
 
 _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put_byname<char>)
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put_byname<wchar_t>)
 #endif
 
 // money_base
public:
     _LIBCPP_INLINE_VISIBILITY int         frac_digits()   const {return do_frac_digits();}
     _LIBCPP_INLINE_VISIBILITY pattern     pos_format()    const {return do_pos_format();}
     _LIBCPP_INLINE_VISIBILITY pattern     neg_format()    const {return do_neg_format();}
 
     static locale::id id;
     static const bool intl = _International;
 
 protected:
-    _LIBCPP_INLINE_VISIBILITY
-    ~moneypunct() {}
+    _LIBCPP_HIDE_FROM_ABI ~moneypunct() override {}
 
     virtual char_type   do_decimal_point() const {return numeric_limits<char_type>::max();}
     virtual char_type   do_thousands_sep() const {return numeric_limits<char_type>::max();}
     virtual string      do_grouping()      const {return string();}
     virtual string_type do_curr_symbol()   const {return string_type();}
     virtual string_type do_positive_sign() const {return string_type();}
     virtual string_type do_negative_sign() const {return string_type(1, '-');}
     virtual int         do_frac_digits()   const {return 0;}
public:
     explicit moneypunct_byname(const char* __nm, size_t __refs = 0)
         : moneypunct<_CharT, _International>(__refs) {init(__nm);}
 
     _LIBCPP_INLINE_VISIBILITY
     explicit moneypunct_byname(const string& __nm, size_t __refs = 0)
         : moneypunct<_CharT, _International>(__refs) {init(__nm.c_str());}
 
 protected:
-    _LIBCPP_INLINE_VISIBILITY
-    ~moneypunct_byname() {}
+    _LIBCPP_HIDE_FROM_ABI ~moneypunct_byname() override {}
 
-    virtual char_type   do_decimal_point() const {return __decimal_point_;}
-    virtual char_type   do_thousands_sep() const {return __thousands_sep_;}
-    virtual string      do_grouping()      const {return __grouping_;}
-    virtual string_type do_curr_symbol()   const {return __curr_symbol_;}
-    virtual string_type do_positive_sign() const {return __positive_sign_;}
-    virtual string_type do_negative_sign() const {return __negative_sign_;}
-    virtual int         do_frac_digits()   const {return __frac_digits_;}
-    virtual pattern     do_pos_format()    const {return __pos_format_;}
-    virtual pattern     do_neg_format()    const {return __neg_format_;}
+     char_type   do_decimal_point() const override {return __decimal_point_;}
+     char_type   do_thousands_sep() const override {return __thousands_sep_;}
+     string      do_grouping()      const override {return __grouping_;}
+     string_type do_curr_symbol()   const override {return __curr_symbol_;}
+     string_type do_positive_sign() const override {return __positive_sign_;}
+     string_type do_negative_sign() const override {return __negative_sign_;}
+     int         do_frac_digits()   const override {return __frac_digits_;}
+     pattern     do_pos_format()    const override {return __pos_format_;}
+     pattern     do_neg_format()    const override {return __neg_format_;}
 
 private:
     char_type   __decimal_point_;
     char_type   __thousands_sep_;
     string      __grouping_;
     string_type __curr_symbol_;
     string_type __positive_sign_;
     string_type __negative_sign_;
iter_type get(iter_type __b, iter_type __e, bool __intl, ios_base& __iob,
                   ios_base::iostate& __err, string_type& __v) const
     {
         return do_get(__b, __e, __intl, __iob, __err, __v);
     }
 
     static locale::id id;
 
 protected:
-
-    _LIBCPP_INLINE_VISIBILITY
-    ~money_get() {}
+    _LIBCPP_HIDE_FROM_ABI ~money_get() override {}
 
     virtual iter_type do_get(iter_type __b, iter_type __e, bool __intl,
                              ios_base& __iob, ios_base::iostate& __err,
                              long double& __v) const;
     virtual iter_type do_get(iter_type __b, iter_type __e, bool __intl,
                              ios_base& __iob, ios_base::iostate& __err,
                              string_type& __v) const;
 
iter_type put(iter_type __s, bool __intl, ios_base& __iob, char_type __fl,
                   const string_type& __digits) const
     {
         return do_put(__s, __intl, __iob, __fl, __digits);
     }
 
     static locale::id id;
 
 protected:
-    _LIBCPP_INLINE_VISIBILITY
-    ~money_put() {}
+    _LIBCPP_HIDE_FROM_ABI ~money_put() override {}
 
     virtual iter_type do_put(iter_type __s, bool __intl, ios_base& __iob,
                              char_type __fl, long double __units) const;
     virtual iter_type do_put(iter_type __s, bool __intl, ios_base& __iob,
                              char_type __fl, const string_type& __digits) const;
 };
 
 template <class _CharT, class _OutputIterator>
public:
     void close(catalog __c) const
     {
         do_close(__c);
     }
 
     static locale::id id;
 
 protected:
-    _LIBCPP_INLINE_VISIBILITY
-    ~messages() {}
+    _LIBCPP_HIDE_FROM_ABI ~messages() override {}
 
     virtual catalog do_open(const basic_string<char>&, const locale&) const;
     virtual string_type do_get(catalog, int __set, int __msgid,
                                const string_type& __dflt) const;
     virtual void do_close(catalog) const;
 };
 
 template <class _CharT>
public:
     explicit messages_byname(const char*, size_t __refs = 0)
         : messages<_CharT>(__refs) {}
 
     _LIBCPP_INLINE_VISIBILITY
     explicit messages_byname(const string&, size_t __refs = 0)
         : messages<_CharT>(__refs) {}
 
 protected:
-    _LIBCPP_INLINE_VISIBILITY
-    ~messages_byname() {}
+    _LIBCPP_HIDE_FROM_ABI ~messages_byname() override {}
 };
 
 _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<char>)
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<wchar_t>)
 #endif
 
 template<class _Codecvt, class _Elem = wchar_t,

libcxx/include/new

 struct _LIBCPP_TYPE_VIS nothrow_t { explicit nothrow_t() = default; };
 extern _LIBCPP_FUNC_VIS const nothrow_t nothrow;
 
 class _LIBCPP_EXCEPTION_ABI bad_alloc
     : public exception
 {
 public:
     bad_alloc() _NOEXCEPT;
-    virtual ~bad_alloc() _NOEXCEPT;
-    virtual const char* what() const _NOEXCEPT;
+    ~bad_alloc() _NOEXCEPT override;
+    const char* what() const _NOEXCEPT override;
 };
 
 class _LIBCPP_EXCEPTION_ABI bad_array_new_length
     : public bad_alloc
 {
 public:
     bad_array_new_length() _NOEXCEPT;
-    virtual ~bad_array_new_length() _NOEXCEPT;
-    virtual const char* what() const _NOEXCEPT;
+    ~bad_array_new_length() _NOEXCEPT override;
+    const char* what() const _NOEXCEPT override;
 };
 
 typedef void (*new_handler)();
 _LIBCPP_FUNC_VIS new_handler set_new_handler(new_handler) _NOEXCEPT;
 _LIBCPP_FUNC_VIS new_handler get_new_handler() _NOEXCEPT;
 
 #endif // !_LIBCPP_ABI_VCRUNTIME
 

libcxx/include/optional

 namespace std  // purposefully not using versioning namespace
 {
 
 class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS bad_optional_access
     : public exception
 {
 public:
     // Get the key function ~bad_optional_access() into the dylib
-    virtual ~bad_optional_access() _NOEXCEPT;
-    virtual const char* what() const _NOEXCEPT;
+    ~bad_optional_access() _NOEXCEPT override;
+    const char* what() const _NOEXCEPT override;
 };
 
 } // namespace std
 
 #if _LIBCPP_STD_VER > 14
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/ostream

public:
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
 
     // 27.7.2.2 Constructor/destructor:
     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
     explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb)
     { this->init(__sb); }
-    virtual ~basic_ostream();
+    ~basic_ostream() override;
 protected:
     inline _LIBCPP_INLINE_VISIBILITY
     basic_ostream(basic_ostream&& __rhs);
 
     // 27.7.2.3 Assign/swap
     inline _LIBCPP_INLINE_VISIBILITY
     basic_ostream& operator=(basic_ostream&& __rhs);
 

libcxx/include/regex

 
 class _LIBCPP_EXCEPTION_ABI regex_error
     : public runtime_error
 {
     regex_constants::error_type __code_;
 public:
     explicit regex_error(regex_constants::error_type __ecode);
     regex_error(const regex_error&) _NOEXCEPT = default;
-    virtual ~regex_error() _NOEXCEPT;
-     _LIBCPP_INLINE_VISIBILITY
+    ~regex_error() _NOEXCEPT override;
     regex_constants::error_type code() const {return __code_;}
 };
 
 template <regex_constants::error_type _Ev>
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_regex_error()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS

 {
     typedef __has_one_state<_CharT> base;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit __owns_one_state(__node<_CharT>* __s)
         : base(__s) {}
 
-    virtual ~__owns_one_state();
+    ~__owns_one_state() override;
 };
 
 template <class _CharT>
 __owns_one_state<_CharT>::~__owns_one_state()
 {
     delete this->first();
 }
 

 
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __match_any_but_newline(__node<_CharT>* __s)
         : base(__s) {}
 
-    virtual void __exec(__state&) const;
+    void __exec(__state&) const override;
 };
 
 template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<char>::__exec(__state&) const;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<wchar_t>::__exec(__state&) const;
 #endif
 
 // __match_char

libcxx/include/sstream

public:
     void swap(basic_stringbuf& __rhs);
 
     // 27.8.1.3 Get and set:
     string_type str() const;
     void str(const string_type& __s);
 
 protected:
     // 27.8.1.4 Overridden virtual functions:
-    virtual int_type underflow();
-    virtual int_type pbackfail(int_type __c = traits_type::eof());
-    virtual int_type overflow (int_type __c = traits_type::eof());
-    virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
-                             ios_base::openmode __wch = ios_base::in | ios_base::out);
+    int_type underflow() override;
+    int_type pbackfail(int_type __c = traits_type::eof()) override;
+    int_type overflow (int_type __c = traits_type::eof()) override;
+    pos_type seekoff(off_type __off, ios_base::seekdir __way,
+                     ios_base::openmode __wch = ios_base::in | ios_base::out) override;
     _LIBCPP_INLINE_VISIBILITY
-    virtual pos_type seekpos(pos_type __sp,
-                             ios_base::openmode __wch = ios_base::in | ios_base::out) {
+    pos_type seekpos(pos_type __sp,
+                     ios_base::openmode __wch = ios_base::in | ios_base::out) override {
         return seekoff(__sp, ios_base::beg, __wch);
     }
 };
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_stringbuf<_CharT, _Traits, _Allocator>::basic_stringbuf(basic_stringbuf&& __rhs)
     : __mode_(__rhs.__mode_)
 {

libcxx/include/stdexcept

private:
     _VSTD::__libcpp_refstring __imp_;
 public:
     explicit logic_error(const string&);
     explicit logic_error(const char*);
 
     logic_error(const logic_error&) _NOEXCEPT;
     logic_error& operator=(const logic_error&) _NOEXCEPT;
 
-    virtual ~logic_error() _NOEXCEPT;
+    ~logic_error() _NOEXCEPT override;
 
-    virtual const char* what() const _NOEXCEPT;
+    const char* what() const _NOEXCEPT override;
 #else
 public:
     explicit logic_error(const _VSTD::string&); // Symbol uses versioned std::string
     _LIBCPP_INLINE_VISIBILITY explicit logic_error(const char* __s) : exception(__s) {}
 #endif
 };
 
 class _LIBCPP_EXCEPTION_ABI runtime_error
     : public exception
 {
 #ifndef _LIBCPP_ABI_VCRUNTIME
 private:
     _VSTD::__libcpp_refstring __imp_;
 public:
     explicit runtime_error(const string&);
     explicit runtime_error(const char*);
 
     runtime_error(const runtime_error&) _NOEXCEPT;
     runtime_error& operator=(const runtime_error&) _NOEXCEPT;
 
-    virtual ~runtime_error() _NOEXCEPT;
+    ~runtime_error() _NOEXCEPT override;
 
-    virtual const char* what() const _NOEXCEPT;
+    const char* what() const _NOEXCEPT override;
 #else
 public:
    explicit runtime_error(const _VSTD::string&); // Symbol uses versioned std::string
    _LIBCPP_INLINE_VISIBILITY explicit runtime_error(const char* __s) : exception(__s) {}
 #endif // _LIBCPP_ABI_VCRUNTIME
 };
 
 class _LIBCPP_EXCEPTION_ABI domain_error
     : public logic_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit domain_error(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit domain_error(const char* __s)   : logic_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
     domain_error(const domain_error&) _NOEXCEPT = default;
-    virtual ~domain_error() _NOEXCEPT;
+    ~domain_error() _NOEXCEPT override;
 #endif
 };
 
 class _LIBCPP_EXCEPTION_ABI invalid_argument
     : public logic_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const char* __s)   : logic_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
     invalid_argument(const invalid_argument&) _NOEXCEPT = default;
-    virtual ~invalid_argument() _NOEXCEPT;
+    ~invalid_argument() _NOEXCEPT override;
 #endif
 };
 
 class _LIBCPP_EXCEPTION_ABI length_error
     : public logic_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit length_error(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit length_error(const char* __s)   : logic_error(__s) {}
 #ifndef _LIBCPP_ABI_VCRUNTIME
     length_error(const length_error&) _NOEXCEPT = default;
-    virtual ~length_error() _NOEXCEPT;
+    ~length_error() _NOEXCEPT override;
 #endif
 };
 
 class _LIBCPP_EXCEPTION_ABI out_of_range
     : public logic_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const char* __s)   : logic_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
     out_of_range(const out_of_range&) _NOEXCEPT = default;
-    virtual ~out_of_range() _NOEXCEPT;
+    ~out_of_range() _NOEXCEPT override;
 #endif
 };
 
 class _LIBCPP_EXCEPTION_ABI range_error
     : public runtime_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit range_error(const string& __s) : runtime_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit range_error(const char* __s)   : runtime_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
     range_error(const range_error&) _NOEXCEPT = default;
-    virtual ~range_error() _NOEXCEPT;
+    ~range_error() _NOEXCEPT override;
 #endif
 };
 
 class _LIBCPP_EXCEPTION_ABI overflow_error
     : public runtime_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const string& __s) : runtime_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const char* __s)   : runtime_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
     overflow_error(const overflow_error&) _NOEXCEPT = default;
-    virtual ~overflow_error() _NOEXCEPT;
+    ~overflow_error() _NOEXCEPT override;
 #endif
 };
 
 class _LIBCPP_EXCEPTION_ABI underflow_error
     : public runtime_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const string& __s) : runtime_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const char* __s)   : runtime_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
     underflow_error(const underflow_error&) _NOEXCEPT = default;
-    virtual ~underflow_error() _NOEXCEPT;
+    ~underflow_error() _NOEXCEPT override;
 #endif
 };
 
 } // namespace std
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // in the dylib

libcxx/include/strstream

 
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     strstreambuf(strstreambuf&& __rhs);
     _LIBCPP_INLINE_VISIBILITY
     strstreambuf& operator=(strstreambuf&& __rhs);
 #endif // _LIBCPP_CXX03_LANG
 
-    virtual ~strstreambuf();
+    ~strstreambuf() override;
 
     void swap(strstreambuf& __rhs);
 
     void freeze(bool __freezefl = true);
     char* str();
     int pcount() const;
 
 protected:
-    virtual int_type overflow (int_type __c = EOF);
-    virtual int_type pbackfail(int_type __c = EOF);
-    virtual int_type underflow();
-    virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
-                             ios_base::openmode __which = ios_base::in | ios_base::out);
-    virtual pos_type seekpos(pos_type __sp,
-                             ios_base::openmode __which = ios_base::in | ios_base::out);
+    int_type overflow (int_type __c = EOF) override;
+    int_type pbackfail(int_type __c = EOF) override;
+    int_type underflow() override;
+    pos_type seekoff(off_type __off, ios_base::seekdir __way,
+                     ios_base::openmode __which = ios_base::in | ios_base::out) override;
+    pos_type seekpos(pos_type __sp,
+                     ios_base::openmode __which = ios_base::in | ios_base::out) override;
 
 private:
     typedef unsigned __mode_type;
     static const __mode_type __allocated = 0x01;
     static const __mode_type __constant  = 0x02;
     static const __mode_type __dynamic   = 0x04;
     static const __mode_type __frozen    = 0x08;
     static const streamsize    __default_alsize = 4096;
#ifndef _LIBCPP_CXX03_LANG
     istrstream& operator=(istrstream&& __rhs)
     {
         istream::operator=(_VSTD::move(__rhs));
         __sb_ = _VSTD::move(__rhs.__sb_);
         return *this;
     }
 #endif // _LIBCPP_CXX03_LANG
 
-    virtual ~istrstream();
+    ~istrstream() override;
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(istrstream& __rhs)
     {
         istream::swap(__rhs);
         __sb_.swap(__rhs.__sb_);
     }
 
#ifndef _LIBCPP_CXX03_LANG
     ostrstream& operator=(ostrstream&& __rhs)
     {
         ostream::operator=(_VSTD::move(__rhs));
         __sb_ = _VSTD::move(__rhs.__sb_);
         return *this;
     }
 #endif // _LIBCPP_CXX03_LANG
 
-    virtual ~ostrstream();
+    ~ostrstream() override;
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(ostrstream& __rhs)
     {
         ostream::swap(__rhs);
         __sb_.swap(__rhs.__sb_);
     }
 
#ifndef _LIBCPP_CXX03_LANG
     strstream& operator=(strstream&& __rhs)
     {
         iostream::operator=(_VSTD::move(__rhs));
         __sb_ = _VSTD::move(__rhs.__sb_);
         return *this;
     }
 #endif // _LIBCPP_CXX03_LANG
 
-    virtual ~strstream();
+    ~strstream() override;
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(strstream& __rhs)
     {
         iostream::swap(__rhs);
         __sb_.swap(__rhs.__sb_);
     }
 

libcxx/include/system_error

#endif
 
     friend class _LIBCPP_HIDDEN __do_message;
 };
 
 class _LIBCPP_HIDDEN __do_message
     : public error_category
 {
 public:
-    virtual string message(int ev) const;
+    string message(int ev) const override;
 };
 
 _LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT;
 _LIBCPP_FUNC_VIS const error_category& system_category() _NOEXCEPT;
 
 class _LIBCPP_TYPE_VIS error_condition
 {
     int __val_;

 public:
     system_error(error_code __ec, const string& __what_arg);
     system_error(error_code __ec, const char* __what_arg);
     system_error(error_code __ec);
     system_error(int __ev, const error_category& __ecat, const string& __what_arg);
     system_error(int __ev, const error_category& __ecat, const char* __what_arg);
     system_error(int __ev, const error_category& __ecat);
     system_error(const system_error&) _NOEXCEPT = default;
-    ~system_error() _NOEXCEPT;
+    ~system_error() _NOEXCEPT override;
 
     _LIBCPP_INLINE_VISIBILITY
     const error_code& code() const _NOEXCEPT {return __ec_;}
 
 private:
     static string __init(const error_code&, string);
 };
 
 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS
 void __throw_system_error(int ev, const char* what_arg);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_SYSTEM_ERROR

libcxx/include/typeinfo

 #endif // defined(_LIBCPP_ABI_MICROSOFT)
 
 class _LIBCPP_EXCEPTION_ABI bad_cast
     : public exception
 {
  public:
   bad_cast() _NOEXCEPT;
   bad_cast(const bad_cast&) _NOEXCEPT = default;
-  virtual ~bad_cast() _NOEXCEPT;
-  virtual const char* what() const _NOEXCEPT;
+  ~bad_cast() _NOEXCEPT override;
+  const char* what() const _NOEXCEPT override;
 };
 
 class _LIBCPP_EXCEPTION_ABI bad_typeid
     : public exception
 {
  public:
   bad_typeid() _NOEXCEPT;
-  virtual ~bad_typeid() _NOEXCEPT;
-  virtual const char* what() const _NOEXCEPT;
+  ~bad_typeid() _NOEXCEPT override;
+  const char* what() const _NOEXCEPT override;
 };
 
 } // namespace std
 
 #endif // defined(_LIBCPP_ABI_VCRUNTIME)
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY

libcxx/include/variant

 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 namespace std { // explicitly not using versioning namespace
 
 class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_VARIANT_ACCESS bad_variant_access : public exception {
 public:
-  virtual const char* what() const _NOEXCEPT;
+   const char* what() const _NOEXCEPT override;
 };
 
 } // namespace std
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
 

libcxx/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp

 
 // The char type of the stream and the char_type of the traits have to match
 
 #include <fstream>
 
 int main(int, char**)
 {
   std::basic_fstream<char, std::char_traits<wchar_t> > f;
-//  expected-error-re@ios:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
-//  expected-error-re@streambuf:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
+// expected-error-re@ios:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
+// expected-error-re@streambuf:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
 
+// expected-error@istream:* {{only virtual member functions can be marked 'override'}}
+// expected-error@istream:* {{only virtual member functions can be marked 'override'}}
+
 // FIXME: As of commit r324062 Clang incorrectly generates a diagnostic about mismatching
 // exception specifications for types which are already invalid for one reason or another.
 // For now we tolerate this diagnostic.
 // expected-error@ostream:* 0-1 {{exception specification of overriding function is more lax than base version}}
 
   return 0;
 }

libcxx/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp

 
 struct test_istream
     : public std::basic_istream<char, std::char_traits<wchar_t> > {};
 
 
 int main(int, char**)
 {
 //  expected-error-re@ios:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
+//  expected-error@istream:* {{only virtual member functions can be marked 'override'}}
 
   return 0;
 }

libcxx/test/libcxx/input.output/iostream.format/output.streams/traits_mismatch.fail.cpp

 
 struct test_ostream
     : public std::basic_ostream<char, std::char_traits<wchar_t> > {};
 
 
 int main(int, char**)
 {
 //  expected-error-re@ios:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
+//  expected-error@ostream:* {{only virtual member functions can be marked 'override'}}
 
   return 0;
 }