rename _LIBCPP_TYPE_VIS_ONLY to _LIBCPP_TEMPLATE_VIS

[compnerd]

Summary

Add _LIBCPP_TEMPLATE_VIS. The new name is more descriptive of what the
intention is. The previous name did not convey the intention of the decoration.
This is mostly a mechanical change, changing instances of _LIBCPP_TYPE_VIS_ONLY
where they were applied to template instances.

[rnk]

This naming change makes a lot of sense to me.

The reason we have this alternative macro is because it makes no sense to dllexport a template. MSVC's semantics for it are not useful at all.

[compnerd]

ping

[mclow.lists]

See : http://lists.cs.uiuc.edu/pipermail/cfe-dev/2013-July/030629.html
and: http://lists.cs.uiuc.edu/pipermail/cfe-dev/2013-August/031214.html
and: http://lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-Mon-20130805/085523.html

for history on this issue.

The last one is Howard's take on some of the (non-mechanical) changes you've proposed.

[rnk]

I don't think we should be using this linkage on non-template types, even if Howard thought they were "header only". Even those tag types can be exported from libc++. If someone takes the address of a tag or once_flag assignment operator, libc++ should have a definition of it. Marking it as dllexport (aka _LIBCPP_TYPE_VISIBILITY) makes that work.

On the other hand, we have things like struct nullptr_t, which are never compiled while building libc++ itself. Saleem has moved to give them no decoration, which means each DSO would get its own set of member functions with distinct addresses.

The upshot is I think we should go forward with this change. This attribute really shouldn't be applied to non-template types, despite what Howard said in the past.

[rnk]

ping

[mclow.lists]

Updated links (since lists.cs.uiuc.edu is no more):

• http://lists.llvm.org/pipermail/cfe-dev/2013-July/030610.html
• http://lists.llvm.org/pipermail/cfe-dev/2013-August/031195.html
• http://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20130805/085461.html

[EricWF]

This version of the patch is super old. A branch new version is up for review here: https://reviews.llvm.org/D28174 If there are no objections I'll commit that patch tomorrow.

[compnerd]

This already was done by @EricWF

include/__config

 # define _LIBCPP_TYPE_VIS
 #endif
 
+#define _LIBCPP_TEMPLATE_VIS
 #define _LIBCPP_TYPE_VIS_ONLY
 #define _LIBCPP_FUNC_VIS_ONLY
 

 #  endif
 #endif
 
+#ifndef _LIBCPP_TEMPLATE_VIS
+# define _LIBCPP_TEMPLATE_VIS _LIBCPP_TYPE_VIS
+#endif
+
 #ifndef _LIBCPP_TYPE_VIS_ONLY
 # define _LIBCPP_TYPE_VIS_ONLY _LIBCPP_TYPE_VIS
 #endif

include/__functional_03

 {
 };
 
-template<class _Fp> class _LIBCPP_TYPE_VIS_ONLY function; // undefined
+template<class _Fp> class _LIBCPP_TEMPLATE_VIS function; // undefined
 
 namespace __function
 {

 }  // __function
 
 template<class _Rp>
-class _LIBCPP_TYPE_VIS_ONLY function<_Rp()>
+class _LIBCPP_TEMPLATE_VIS function<_Rp()>
 {
     typedef __function::__base<_Rp()> __base;
     aligned_storage<3*sizeof(void*)>::type __buf_;

 #endif  // _LIBCPP_NO_RTTI
 
 template<class _Rp, class _A0>
-class _LIBCPP_TYPE_VIS_ONLY function<_Rp(_A0)>
+class _LIBCPP_TEMPLATE_VIS function<_Rp(_A0)>
     : public unary_function<_A0, _Rp>
 {
     typedef __function::__base<_Rp(_A0)> __base;

 #endif  // _LIBCPP_NO_RTTI
 
 template<class _Rp, class _A0, class _A1>
-class _LIBCPP_TYPE_VIS_ONLY function<_Rp(_A0, _A1)>
+class _LIBCPP_TEMPLATE_VIS function<_Rp(_A0, _A1)>
     : public binary_function<_A0, _A1, _Rp>
 {
     typedef __function::__base<_Rp(_A0, _A1)> __base;

 #endif  // _LIBCPP_NO_RTTI
 
 template<class _Rp, class _A0, class _A1, class _A2>
-class _LIBCPP_TYPE_VIS_ONLY function<_Rp(_A0, _A1, _A2)>
+class _LIBCPP_TEMPLATE_VIS function<_Rp(_A0, _A1, _A2)>
 {
     typedef __function::__base<_Rp(_A0, _A1, _A2)> __base;
     aligned_storage<3*sizeof(void*)>::type __buf_;

 {return __x.swap(__y);}
 
 template<class _Tp> struct __is_bind_expression : public false_type {};
-template<class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_bind_expression
+template<class _Tp> struct _LIBCPP_TEMPLATE_VIS is_bind_expression
     : public __is_bind_expression<typename remove_cv<_Tp>::type> {};
 
 template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {};
-template<class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_placeholder
+template<class _Tp> struct _LIBCPP_TEMPLATE_VIS is_placeholder
     : public __is_placeholder<typename remove_cv<_Tp>::type> {};
 
 namespace placeholders

include/__functional_base

 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Arg, class _Result>
-struct _LIBCPP_TYPE_VIS_ONLY unary_function
+struct _LIBCPP_TEMPLATE_VIS unary_function
 {
     typedef _Arg    argument_type;
     typedef _Result result_type;
 };
 
 template <class _Arg1, class _Arg2, class _Result>
-struct _LIBCPP_TYPE_VIS_ONLY binary_function
+struct _LIBCPP_TEMPLATE_VIS binary_function
 {
     typedef _Arg1   first_argument_type;
     typedef _Arg2   second_argument_type;
     typedef _Result result_type;
 };
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY hash;
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS hash;
 
 template <class _Tp>
 struct __has_result_type

 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS_ONLY less : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TEMPLATE_VIS less : binary_function<_Tp, _Tp, bool>
 {
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 
     bool operator()(const _Tp& __x, const _Tp& __y) const

 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY less<void>
+struct _LIBCPP_TEMPLATE_VIS less<void>
 {
     template <class _T1, class _T2> 
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

 };
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY reference_wrapper
+class _LIBCPP_TEMPLATE_VIS reference_wrapper
     : public __weak_result_type<_Tp>
 {
 public:

 
 // allocator_arg_t
 
-struct _LIBCPP_TYPE_VIS_ONLY allocator_arg_t { };
+struct _LIBCPP_TEMPLATE_VIS allocator_arg_t { };
 
 #if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_MEMORY)
 extern const allocator_arg_t allocator_arg;

 };
 
 template <class _Tp, class _Alloc>
-struct _LIBCPP_TYPE_VIS_ONLY uses_allocator
+struct _LIBCPP_TEMPLATE_VIS uses_allocator
     : public __uses_allocator<_Tp, _Alloc>
 {
 };

include/__functional_base_03

 };
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY reference_wrapper
+class _LIBCPP_TEMPLATE_VIS reference_wrapper
     : public __weak_result_type<_Tp>
 {
 public:

include/__hash_table

 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc> class __hash_table;
-template <class _ConstNodePtr> class _LIBCPP_TYPE_VIS_ONLY __hash_const_iterator;
-template <class _HashIterator> class _LIBCPP_TYPE_VIS_ONLY __hash_map_iterator;
-template <class _HashIterator> class _LIBCPP_TYPE_VIS_ONLY __hash_map_const_iterator;
+template <class _ConstNodePtr> class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
+template <class _HashIterator> class _LIBCPP_TEMPLATE_VIS __hash_map_iterator;
+template <class _HashIterator> class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-    class _LIBCPP_TYPE_VIS_ONLY unordered_map;
+    class _LIBCPP_TEMPLATE_VIS unordered_map;
 
 template <class _NodePtr>
-class _LIBCPP_TYPE_VIS_ONLY __hash_iterator
+class _LIBCPP_TEMPLATE_VIS __hash_iterator
 {
     typedef _NodePtr __node_pointer;
 

 #endif
 
     template <class, class, class, class> friend class __hash_table;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_iterator;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_map_iterator;
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_multimap;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_iterator;
+    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
+    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
 };
 
 template <class _ConstNodePtr>
-class _LIBCPP_TYPE_VIS_ONLY __hash_const_iterator
+class _LIBCPP_TEMPLATE_VIS __hash_const_iterator
 {
     typedef _ConstNodePtr __node_pointer;
 

 #endif
 
     template <class, class, class, class> friend class __hash_table;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_map_const_iterator;
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_multimap;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
+    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
+    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
 };
 
-template <class _ConstNodePtr> class _LIBCPP_TYPE_VIS_ONLY __hash_const_local_iterator;
+template <class _ConstNodePtr> class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
 
 template <class _NodePtr>
-class _LIBCPP_TYPE_VIS_ONLY __hash_local_iterator
+class _LIBCPP_TEMPLATE_VIS __hash_local_iterator
 {
     typedef _NodePtr __node_pointer;
 

         }
 #endif
     template <class, class, class, class> friend class __hash_table;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_local_iterator;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_map_iterator;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_iterator;
 };
 
 template <class _ConstNodePtr>
-class _LIBCPP_TYPE_VIS_ONLY __hash_const_local_iterator
+class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator
 {
     typedef _ConstNodePtr __node_pointer;
 

         }
 #endif
     template <class, class, class, class> friend class __hash_table;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_map_const_iterator;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
 };
 
 template <class _Alloc>

     void __deallocate(__node_pointer __np) _NOEXCEPT;
     __node_pointer __detach() _NOEXCEPT;
 
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_multimap;
+    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
+    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
 };
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>

include/__locale

 // template <class _CharT> class collate;
 
 template <class _CharT>
-class _LIBCPP_TYPE_VIS_ONLY collate
+class _LIBCPP_TEMPLATE_VIS collate
     : public locale::facet
 {
 public:

 
 // template <class CharT> class collate_byname;
 
-template <class _CharT> class _LIBCPP_TYPE_VIS_ONLY collate_byname;
+template <class _CharT> class _LIBCPP_TEMPLATE_VIS collate_byname;
 
 template <>
 class _LIBCPP_TYPE_VIS collate_byname<char>

     _LIBCPP_ALWAYS_INLINE ctype_base() {}
 };
 
-template <class _CharT> class _LIBCPP_TYPE_VIS_ONLY ctype;
+template <class _CharT> class _LIBCPP_TEMPLATE_VIS ctype;
 
 template <>
 class _LIBCPP_TYPE_VIS ctype<wchar_t>

 
 // template <class CharT> class ctype_byname;
 
-template <class _CharT> class _LIBCPP_TYPE_VIS_ONLY ctype_byname;
+template <class _CharT> class _LIBCPP_TEMPLATE_VIS ctype_byname;
 
 template <>
 class _LIBCPP_TYPE_VIS ctype_byname<char>

 
 // template <class internT, class externT, class stateT> class codecvt;
 
-template <class _InternT, class _ExternT, class _StateT> class _LIBCPP_TYPE_VIS_ONLY codecvt;
+template <class _InternT, class _ExternT, class _StateT> class _LIBCPP_TEMPLATE_VIS codecvt;
 
 // template <> class codecvt<char, char, mbstate_t>
 

 // template <class _InternT, class _ExternT, class _StateT> class codecvt_byname
 
 template <class _InternT, class _ExternT, class _StateT>
-class _LIBCPP_TYPE_VIS_ONLY codecvt_byname
+class _LIBCPP_TEMPLATE_VIS codecvt_byname
     : public codecvt<_InternT, _ExternT, _StateT>
 {
 public:

 
 // template <class charT> class numpunct
 
-template <class _CharT> class _LIBCPP_TYPE_VIS_ONLY numpunct;
+template <class _CharT> class _LIBCPP_TEMPLATE_VIS numpunct;
 
 template <>
 class _LIBCPP_TYPE_VIS numpunct<char>

 
 // template <class charT> class numpunct_byname
 
-template <class charT> class _LIBCPP_TYPE_VIS_ONLY numpunct_byname;
+template <class charT> class _LIBCPP_TEMPLATE_VIS numpunct_byname;
 
 template <>
 class _LIBCPP_TYPE_VIS numpunct_byname<char>

include/__mutex_base

 #endif
 
 template <class _Mutex>
-class _LIBCPP_TYPE_VIS_ONLY lock_guard
+class _LIBCPP_TEMPLATE_VIS lock_guard
 {
 public:
     typedef _Mutex mutex_type;

 };
 
 template <class _Mutex>
-class _LIBCPP_TYPE_VIS_ONLY unique_lock
+class _LIBCPP_TEMPLATE_VIS unique_lock
 {
 public:
     typedef _Mutex mutex_type;

include/__tree

 
 template <class _Tp, class _Compare, class _Allocator> class __tree;
 template <class _Tp, class _NodePtr, class _DiffType>
-    class _LIBCPP_TYPE_VIS_ONLY __tree_iterator;
+    class _LIBCPP_TEMPLATE_VIS __tree_iterator;
 template <class _Tp, class _ConstNodePtr, class _DiffType>
-    class _LIBCPP_TYPE_VIS_ONLY __tree_const_iterator;
+    class _LIBCPP_TEMPLATE_VIS __tree_const_iterator;
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-    class _LIBCPP_TYPE_VIS_ONLY map;
+    class _LIBCPP_TEMPLATE_VIS map;
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-    class _LIBCPP_TYPE_VIS_ONLY multimap;
+    class _LIBCPP_TEMPLATE_VIS multimap;
 template <class _Key, class _Compare, class _Allocator>
-    class _LIBCPP_TYPE_VIS_ONLY set;
+    class _LIBCPP_TEMPLATE_VIS set;
 template <class _Key, class _Compare, class _Allocator>
-    class _LIBCPP_TYPE_VIS_ONLY multiset;
+    class _LIBCPP_TEMPLATE_VIS multiset;
 
 /*
 

 #endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
 };
 
-template <class _TreeIterator> class _LIBCPP_TYPE_VIS_ONLY __map_iterator;
-template <class _TreeIterator> class _LIBCPP_TYPE_VIS_ONLY __map_const_iterator;
+template <class _TreeIterator> class _LIBCPP_TEMPLATE_VIS __map_iterator;
+template <class _TreeIterator> class _LIBCPP_TEMPLATE_VIS __map_const_iterator;
 
 template <class _Tp, class _NodePtr, class _DiffType>
-class _LIBCPP_TYPE_VIS_ONLY __tree_iterator
+class _LIBCPP_TEMPLATE_VIS __tree_iterator
 {
     typedef _NodePtr                                              __node_pointer;
     typedef typename pointer_traits<__node_pointer>::element_type __node;

     _LIBCPP_INLINE_VISIBILITY
     explicit __tree_iterator(__node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
     template <class, class, class> friend class __tree;
-    template <class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY __tree_const_iterator;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __map_iterator;
-    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY map;
-    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY multimap;
-    template <class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY set;
-    template <class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY multiset;
+    template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS __tree_const_iterator;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS __map_iterator;
+    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
+    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
+    template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS set;
+    template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS multiset;
 };
 
 template <class _Tp, class _ConstNodePtr, class _DiffType>
-class _LIBCPP_TYPE_VIS_ONLY __tree_const_iterator
+class _LIBCPP_TEMPLATE_VIS __tree_const_iterator
 {
     typedef _ConstNodePtr                                         __node_pointer;
     typedef typename pointer_traits<__node_pointer>::element_type __node;

     explicit __tree_const_iterator(__node_pointer __p) _NOEXCEPT
         : __ptr_(__p) {}
     template <class, class, class> friend class __tree;
-    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY map;
-    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY multimap;
-    template <class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY set;
-    template <class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY multiset;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __map_const_iterator;
+    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
+    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
+    template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS set;
+    template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS multiset;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS __map_const_iterator;
 };
 
 template <class _Tp, class _Compare, class _Allocator>

     __node_pointer __detach();
     static __node_pointer __detach(__node_pointer);
 
-    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY map;
-    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY multimap;
+    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
+    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
 };
 
 template <class _Tp, class _Compare, class _Allocator>

include/__tuple

 struct __lazy_not : integral_constant<bool, !_Pred::type::value> {};
 
 
-template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_size;
+template <class _Tp> class _LIBCPP_TEMPLATE_VIS tuple_size;
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY tuple_size<const _Tp>
+class _LIBCPP_TEMPLATE_VIS tuple_size<const _Tp>
     : public tuple_size<_Tp> {};
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY tuple_size<volatile _Tp>
+class _LIBCPP_TEMPLATE_VIS tuple_size<volatile _Tp>
     : public tuple_size<_Tp> {};
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY tuple_size<const volatile _Tp>
+class _LIBCPP_TEMPLATE_VIS tuple_size<const volatile _Tp>
     : public tuple_size<_Tp> {};
 
-template <size_t _Ip, class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_element;
+template <size_t _Ip, class _Tp> class _LIBCPP_TEMPLATE_VIS tuple_element;
 
 template <size_t _Ip, class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, const _Tp>
+class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const _Tp>
 {
 public:
     typedef typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type;
 };
 
 template <size_t _Ip, class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, volatile _Tp>
+class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, volatile _Tp>
 {
 public:
     typedef typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type;
 };
 
 template <size_t _Ip, class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, const volatile _Tp>
+class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const volatile _Tp>
 {
 public:
     typedef typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type;
 };
 
-template <class ..._Tp> class _LIBCPP_TYPE_VIS_ONLY tuple;
-template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS_ONLY pair;
-template <class _Tp, size_t _Size> struct _LIBCPP_TYPE_VIS_ONLY array;
+template <class ..._Tp> class _LIBCPP_TEMPLATE_VIS tuple;
+template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS pair;
+template <class _Tp, size_t _Size> struct _LIBCPP_TEMPLATE_VIS array;
 
 template <class _Tp> struct __tuple_like : false_type {};
 

 template <class ..._Tp> struct __tuple_types {};
 
 template <size_t _Ip>
-class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, __tuple_types<> >
+class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, __tuple_types<> >
 {
 public:
     static_assert(_Ip == 0, "tuple_element index out of range");

 };
 
 template <class _Hp, class ..._Tp>
-class _LIBCPP_TYPE_VIS_ONLY tuple_element<0, __tuple_types<_Hp, _Tp...> >
+class _LIBCPP_TEMPLATE_VIS tuple_element<0, __tuple_types<_Hp, _Tp...> >
 {
 public:
     typedef _Hp type;
 };
 
 template <size_t _Ip, class _Hp, class ..._Tp>
-class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, __tuple_types<_Hp, _Tp...> >
+class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, __tuple_types<_Hp, _Tp...> >
 {
 public:
     typedef typename tuple_element<_Ip-1, __tuple_types<_Tp...> >::type type;
 };
 
 template <class ..._Tp>
-class _LIBCPP_TYPE_VIS_ONLY tuple_size<__tuple_types<_Tp...> >
+class _LIBCPP_TEMPLATE_VIS tuple_size<__tuple_types<_Tp...> >
     : public integral_constant<size_t, sizeof...(_Tp)>
 {
 };

include/__tuple_03

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_size;
-template <size_t _Ip, class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_element;
+template <class _Tp> class _LIBCPP_TEMPLATE_VIS tuple_size;
+template <size_t _Ip, class _Tp> class _LIBCPP_TEMPLATE_VIS tuple_element;
 
 _LIBCPP_END_NAMESPACE_STD
 

include/array

 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, size_t _Size>
-struct _LIBCPP_TYPE_VIS_ONLY array
+struct _LIBCPP_TEMPLATE_VIS array
 {
     // types:
     typedef array __self;

 }
 
 template <class _Tp, size_t _Size>
-class _LIBCPP_TYPE_VIS_ONLY tuple_size<array<_Tp, _Size> >
+class _LIBCPP_TEMPLATE_VIS tuple_size<array<_Tp, _Size> >
     : public integral_constant<size_t, _Size> {};
 
 template <class _Tp, size_t _Size>
-class _LIBCPP_TYPE_VIS_ONLY tuple_size<const array<_Tp, _Size> >
+class _LIBCPP_TEMPLATE_VIS tuple_size<const array<_Tp, _Size> >
     : public integral_constant<size_t, _Size> {};
 
 template <size_t _Ip, class _Tp, size_t _Size>
-class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, array<_Tp, _Size> >
+class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, array<_Tp, _Size> >
 {
 public:
     typedef _Tp type;
 };
 
 template <size_t _Ip, class _Tp, size_t _Size>
-class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, const array<_Tp, _Size> >
+class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const array<_Tp, _Size> >
 {
 public:
     typedef const _Tp type;

include/bitset

 {
 }
 
-template <size_t _Size> class _LIBCPP_TYPE_VIS_ONLY bitset;
-template <size_t _Size> struct _LIBCPP_TYPE_VIS_ONLY hash<bitset<_Size> >;
+template <size_t _Size> class _LIBCPP_TEMPLATE_VIS bitset;
+template <size_t _Size> struct _LIBCPP_TEMPLATE_VIS hash<bitset<_Size> >;
 
 template <size_t _Size>
-class _LIBCPP_TYPE_VIS_ONLY bitset
+class _LIBCPP_TEMPLATE_VIS bitset
     : private __bitset<_Size == 0 ? 0 : (_Size - 1) / (sizeof(size_t) * CHAR_BIT) + 1, _Size>
 {
 public:

 }
 
 template <size_t _Size>
-struct _LIBCPP_TYPE_VIS_ONLY hash<bitset<_Size> >
+struct _LIBCPP_TEMPLATE_VIS hash<bitset<_Size> >
     : public unary_function<bitset<_Size>, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

include/chrono

 namespace chrono
 {
 
-template <class _Rep, class _Period = ratio<1> > class _LIBCPP_TYPE_VIS_ONLY duration;
+template <class _Rep, class _Period = ratio<1> > class _LIBCPP_TEMPLATE_VIS duration;
 
 template <class _Tp>
 struct __is_duration : false_type {};

 } // chrono
 
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
-struct _LIBCPP_TYPE_VIS_ONLY common_type<chrono::duration<_Rep1, _Period1>,
+struct _LIBCPP_TEMPLATE_VIS common_type<chrono::duration<_Rep1, _Period1>,
                                          chrono::duration<_Rep2, _Period2> >
 {
     typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,

 }
 
 template <class _Rep>
-struct _LIBCPP_TYPE_VIS_ONLY treat_as_floating_point : is_floating_point<_Rep> {};
+struct _LIBCPP_TEMPLATE_VIS treat_as_floating_point : is_floating_point<_Rep> {};
 
 template <class _Rep>
-struct _LIBCPP_TYPE_VIS_ONLY duration_values
+struct _LIBCPP_TEMPLATE_VIS duration_values
 {
 public:
     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() {return _Rep(0);}

 // duration
 
 template <class _Rep, class _Period>
-class _LIBCPP_TYPE_VIS_ONLY duration
+class _LIBCPP_TEMPLATE_VIS duration
 {
     static_assert(!__is_duration<_Rep>::value, "A duration representation can not be a duration");
     static_assert(__is_ratio<_Period>::value, "Second template parameter of duration must be a std::ratio");

 //////////////////////////////////////////////////////////
 
 template <class _Clock, class _Duration = typename _Clock::duration>
-class _LIBCPP_TYPE_VIS_ONLY time_point
+class _LIBCPP_TEMPLATE_VIS time_point
 {
     static_assert(__is_duration<_Duration>::value,
                   "Second template parameter of time_point must be a std::chrono::duration");

 } // chrono
 
 template <class _Clock, class _Duration1, class _Duration2>
-struct _LIBCPP_TYPE_VIS_ONLY common_type<chrono::time_point<_Clock, _Duration1>,
+struct _LIBCPP_TEMPLATE_VIS common_type<chrono::time_point<_Clock, _Duration1>,
                                          chrono::time_point<_Clock, _Duration2> >
 {
     typedef chrono::time_point<_Clock, typename common_type<_Duration1, _Duration2>::type> type;

include/codecvt

 
 template <class _Elem, unsigned long _Maxcode = 0x10ffff,
           codecvt_mode _Mode = (codecvt_mode)0>
-class _LIBCPP_TYPE_VIS_ONLY codecvt_utf8
+class _LIBCPP_TEMPLATE_VIS codecvt_utf8
     : public __codecvt_utf8<_Elem>
 {
 public:

 
 template <class _Elem, unsigned long _Maxcode = 0x10ffff,
           codecvt_mode _Mode = (codecvt_mode)0>
-class _LIBCPP_TYPE_VIS_ONLY codecvt_utf16
+class _LIBCPP_TEMPLATE_VIS codecvt_utf16
     : public __codecvt_utf16<_Elem, _Mode & little_endian>
 {
 public:

 
 template <class _Elem, unsigned long _Maxcode = 0x10ffff,
           codecvt_mode _Mode = (codecvt_mode)0>
-class _LIBCPP_TYPE_VIS_ONLY codecvt_utf8_utf16
+class _LIBCPP_TEMPLATE_VIS codecvt_utf8_utf16
     : public __codecvt_utf8_utf16<_Elem>
 {
 public:

include/complex

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _Tp> class _LIBCPP_TYPE_VIS_ONLY complex;
+template<class _Tp> class _LIBCPP_TEMPLATE_VIS complex;
 
 template<class _Tp> complex<_Tp> operator*(const complex<_Tp>& __z, const complex<_Tp>& __w);
 template<class _Tp> complex<_Tp> operator/(const complex<_Tp>& __x, const complex<_Tp>& __y);
 
 template<class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY complex
+class _LIBCPP_TEMPLATE_VIS complex
 {
 public:
     typedef _Tp value_type;

         }
 };
 
-template<> class _LIBCPP_TYPE_VIS_ONLY complex<double>;
-template<> class _LIBCPP_TYPE_VIS_ONLY complex<long double>;
+template<> class _LIBCPP_TEMPLATE_VIS complex<double>;
+template<> class _LIBCPP_TEMPLATE_VIS complex<long double>;
 
 template<>
-class _LIBCPP_TYPE_VIS_ONLY complex<float>
+class _LIBCPP_TEMPLATE_VIS complex<float>
 {
     float __re_;
     float __im_;

 };
 
 template<>
-class _LIBCPP_TYPE_VIS_ONLY complex<double>
+class _LIBCPP_TEMPLATE_VIS complex<double>
 {
     double __re_;
     double __im_;

 };
 
 template<>
-class _LIBCPP_TYPE_VIS_ONLY complex<long double>
+class _LIBCPP_TEMPLATE_VIS complex<long double>
 {
     long double __re_;
     long double __im_;

include/deque

 
 template <class _ValueType, class _Pointer, class _Reference, class _MapPointer,
           class _DiffType, _DiffType _BlockSize>
-class _LIBCPP_TYPE_VIS_ONLY __deque_iterator;
+class _LIBCPP_TEMPLATE_VIS __deque_iterator;
 
 template <class _RAIter,
           class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>

 
 template <class _ValueType, class _Pointer, class _Reference, class _MapPointer,
           class _DiffType, _DiffType _BlockSize>
-class _LIBCPP_TYPE_VIS_ONLY __deque_iterator
+class _LIBCPP_TEMPLATE_VIS __deque_iterator
 {
     typedef _MapPointer __map_iterator;
 public:

         : __m_iter_(__m), __ptr_(__p) {}
 
     template <class _Tp, class _Ap> friend class __deque_base;
-    template <class _Tp, class _Ap> friend class _LIBCPP_TYPE_VIS_ONLY deque;
+    template <class _Tp, class _Ap> friend class _LIBCPP_TEMPLATE_VIS deque;
     template <class _Vp, class _Pp, class _Rp, class _MP, class _Dp, _Dp>
-        friend class _LIBCPP_TYPE_VIS_ONLY __deque_iterator;
+        friend class _LIBCPP_TEMPLATE_VIS __deque_iterator;
 
     template <class _RAIter,
               class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>

 }
 
 template <class _Tp, class _Allocator = allocator<_Tp> >
-class _LIBCPP_TYPE_VIS_ONLY deque
+class _LIBCPP_TEMPLATE_VIS deque
     : private __deque_base<_Tp, _Allocator>
 {
 public:

include/experimental/dynarray

 namespace std { namespace experimental { inline namespace __array_extensions_v1 {
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY dynarray
+struct _LIBCPP_TEMPLATE_VIS dynarray
 {
 public:
     // types:

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 template <class _Tp, class _Alloc>
-struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<std::experimental::dynarray<_Tp>, _Alloc> : true_type {};
+struct _LIBCPP_TEMPLATE_VIS uses_allocator<std::experimental::dynarray<_Tp>, _Alloc> : true_type {};
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // if _LIBCPP_STD_VER > 11 

include/experimental/optional

 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY hash<std::experimental::optional<_Tp> >
+struct _LIBCPP_TEMPLATE_VIS hash<std::experimental::optional<_Tp> >
 {
     typedef std::experimental::optional<_Tp> argument_type;
     typedef size_t        result_type;

include/experimental/string_view

 _LIBCPP_BEGIN_NAMESPACE_LFTS
 
     template<class _CharT, class _Traits = _VSTD::char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS_ONLY basic_string_view {
+    class _LIBCPP_TEMPLATE_VIS basic_string_view {
     public:
         // types
         typedef _Traits                                    traits_type;

 // [string.view.hash]
 // Shamelessly stolen from <string>
 template<class _CharT, class _Traits>
-struct _LIBCPP_TYPE_VIS_ONLY hash<std::experimental::basic_string_view<_CharT, _Traits> >
+struct _LIBCPP_TEMPLATE_VIS hash<std::experimental::basic_string_view<_CharT, _Traits> >
     : public unary_function<std::experimental::basic_string_view<_CharT, _Traits>, size_t>
 {
     size_t operator()(const std::experimental::basic_string_view<_CharT, _Traits>& __val) const _NOEXCEPT;

include/experimental/utility

 
 _LIBCPP_BEGIN_NAMESPACE_LFTS
 
-  struct _LIBCPP_TYPE_VIS_ONLY erased_type { };
+  struct _LIBCPP_TEMPLATE_VIS erased_type { };
 
 _LIBCPP_END_NAMESPACE_LFTS
 

include/ext/__hash

 namespace __gnu_cxx {
 using namespace std;
 
-template <typename _Tp> struct _LIBCPP_TYPE_VIS_ONLY hash { };
+template <typename _Tp> struct _LIBCPP_TEMPLATE_VIS hash { };
 
-template <> struct _LIBCPP_TYPE_VIS_ONLY hash<const char*>
+template <> struct _LIBCPP_TEMPLATE_VIS hash<const char*>
     : public unary_function<const char*, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

     }
 };
 
-template <> struct _LIBCPP_TYPE_VIS_ONLY hash<char *>
+template <> struct _LIBCPP_TEMPLATE_VIS hash<char *>
     : public unary_function<char*, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

     }
 };
 
-template <> struct _LIBCPP_TYPE_VIS_ONLY hash<char>
+template <> struct _LIBCPP_TEMPLATE_VIS hash<char>
     : public unary_function<char, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

     }
 };
 
-template <> struct _LIBCPP_TYPE_VIS_ONLY hash<signed char>
+template <> struct _LIBCPP_TEMPLATE_VIS hash<signed char>
     : public unary_function<signed char, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

     }
 };
 
-template <> struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned char>
+template <> struct _LIBCPP_TEMPLATE_VIS hash<unsigned char>
     : public unary_function<unsigned char, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

     }
 };
 
-template <> struct _LIBCPP_TYPE_VIS_ONLY hash<short>
+template <> struct _LIBCPP_TEMPLATE_VIS hash<short>
     : public unary_function<short, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

     }
 };
 
-template <> struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned short>
+template <> struct _LIBCPP_TEMPLATE_VIS hash<unsigned short>
     : public unary_function<unsigned short, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

     }
 };
 
-template <> struct _LIBCPP_TYPE_VIS_ONLY hash<int>
+template <> struct _LIBCPP_TEMPLATE_VIS hash<int>
     : public unary_function<int, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

     }
 };
 
-template <> struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned int>
+template <> struct _LIBCPP_TEMPLATE_VIS hash<unsigned int>
     : public unary_function<unsigned int, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

     }
 };
 
-template <> struct _LIBCPP_TYPE_VIS_ONLY hash<long>
+template <> struct _LIBCPP_TEMPLATE_VIS hash<long>
     : public unary_function<long, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

     }
 };
 
-template <> struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned long>
+template <> struct _LIBCPP_TEMPLATE_VIS hash<unsigned long>
     : public unary_function<unsigned long, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

include/ext/hash_map

 };
 
 template <class _HashIterator>
-class _LIBCPP_TYPE_VIS_ONLY __hash_map_iterator
+class _LIBCPP_TEMPLATE_VIS __hash_map_iterator
 {
     _HashIterator __i_;
 

     bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
         {return __x.__i_ != __y.__i_;}
 
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY hash_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY hash_multimap;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_iterator;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_local_iterator;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_map_const_iterator;
+    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS hash_map;
+    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS hash_multimap;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
 };
 
 template <class _HashIterator>
-class _LIBCPP_TYPE_VIS_ONLY __hash_map_const_iterator
+class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator
 {
     _HashIterator __i_;
 

     bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
         {return __x.__i_ != __y.__i_;}
 
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY hash_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY hash_multimap;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_iterator;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_local_iterator;
+    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS hash_map;
+    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS hash_multimap;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
 };
 
 template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
           class _Alloc = allocator<pair<const _Key, _Tp> > >
-class _LIBCPP_TYPE_VIS_ONLY hash_map
+class _LIBCPP_TEMPLATE_VIS hash_map
 {
 public:
     // types

 
 template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
           class _Alloc = allocator<pair<const _Key, _Tp> > >
-class _LIBCPP_TYPE_VIS_ONLY hash_multimap
+class _LIBCPP_TEMPLATE_VIS hash_multimap
 {
 public:
     // types

include/ext/hash_set

 
 template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
           class _Alloc = allocator<_Value> >
-class _LIBCPP_TYPE_VIS_ONLY hash_set
+class _LIBCPP_TEMPLATE_VIS hash_set
 {
 public:
     // types

 
 template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
           class _Alloc = allocator<_Value> >
-class _LIBCPP_TYPE_VIS_ONLY hash_multiset
+class _LIBCPP_TEMPLATE_VIS hash_multiset
 {
 public:
     // types

include/forward_list

     value_type __value_;
 };
 
-template<class _Tp, class _Alloc> class _LIBCPP_TYPE_VIS_ONLY forward_list;
-template<class _NodeConstPtr> class _LIBCPP_TYPE_VIS_ONLY __forward_list_const_iterator;
+template<class _Tp, class _Alloc> class _LIBCPP_TEMPLATE_VIS forward_list;
+template<class _NodeConstPtr> class _LIBCPP_TEMPLATE_VIS __forward_list_const_iterator;
 
 template <class _NodePtr>
-class _LIBCPP_TYPE_VIS_ONLY __forward_list_iterator
+class _LIBCPP_TEMPLATE_VIS __forward_list_iterator
 {
     typedef _NodePtr __node_pointer;
 

     _LIBCPP_INLINE_VISIBILITY
     explicit __forward_list_iterator(__node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
 
-    template<class, class> friend class _LIBCPP_TYPE_VIS_ONLY forward_list;
-    template<class> friend class _LIBCPP_TYPE_VIS_ONLY __forward_list_const_iterator;
+    template<class, class> friend class _LIBCPP_TEMPLATE_VIS forward_list;
+    template<class> friend class _LIBCPP_TEMPLATE_VIS __forward_list_const_iterator;
 
 public:
     typedef forward_iterator_tag                              iterator_category;

 };
 
 template <class _NodeConstPtr>
-class _LIBCPP_TYPE_VIS_ONLY __forward_list_const_iterator
+class _LIBCPP_TEMPLATE_VIS __forward_list_const_iterator
 {
     typedef _NodeConstPtr __node_const_pointer;
 

 }
 
 template <class _Tp, class _Alloc = allocator<_Tp> >
-class _LIBCPP_TYPE_VIS_ONLY forward_list
+class _LIBCPP_TEMPLATE_VIS forward_list
     : private __forward_list_base<_Tp, _Alloc>
 {
     typedef __forward_list_base<_Tp, _Alloc> base;

include/fstream

 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS_ONLY basic_filebuf
+class _LIBCPP_TEMPLATE_VIS basic_filebuf
     : public basic_streambuf<_CharT, _Traits>
 {
 public:

 // basic_ifstream
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS_ONLY basic_ifstream
+class _LIBCPP_TEMPLATE_VIS basic_ifstream
     : public basic_istream<_CharT, _Traits>
 {
 public:

 // basic_ofstream
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS_ONLY basic_ofstream
+class _LIBCPP_TEMPLATE_VIS basic_ofstream
     : public basic_ostream<_CharT, _Traits>
 {
 public:

 // basic_fstream
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS_ONLY basic_fstream
+class _LIBCPP_TEMPLATE_VIS basic_fstream
     : public basic_iostream<_CharT, _Traits>
 {
 public:

include/functional

 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS_ONLY plus : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TEMPLATE_VIS plus : binary_function<_Tp, _Tp, _Tp>
 {
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const

 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY plus<void>
+struct _LIBCPP_TEMPLATE_VIS plus<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS_ONLY minus : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TEMPLATE_VIS minus : binary_function<_Tp, _Tp, _Tp>
 {
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const

 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY minus<void>
+struct _LIBCPP_TEMPLATE_VIS minus<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS_ONLY multiplies : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TEMPLATE_VIS multiplies : binary_function<_Tp, _Tp, _Tp>
 {
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const

 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY multiplies<void>
+struct _LIBCPP_TEMPLATE_VIS multiplies<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS_ONLY divides : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TEMPLATE_VIS divides : binary_function<_Tp, _Tp, _Tp>
 {
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const

 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY divides<void>
+struct _LIBCPP_TEMPLATE_VIS divides<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS_ONLY modulus : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TEMPLATE_VIS modulus : binary_function<_Tp, _Tp, _Tp>
 {
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const

 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY modulus<void>
+struct _LIBCPP_TEMPLATE_VIS modulus<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS_ONLY negate : unary_function<_Tp, _Tp>
+struct _LIBCPP_TEMPLATE_VIS negate : unary_function<_Tp, _Tp>
 {
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const

 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY negate<void>
+struct _LIBCPP_TEMPLATE_VIS negate<void>
 {
     template <class _Tp>
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS_ONLY equal_to : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TEMPLATE_VIS equal_to : binary_function<_Tp, _Tp, bool>
 {
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const

 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY equal_to<void>
+struct _LIBCPP_TEMPLATE_VIS equal_to<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS_ONLY not_equal_to : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TEMPLATE_VIS not_equal_to : binary_function<_Tp, _Tp, bool>
 {
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const

 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY not_equal_to<void>
+struct _LIBCPP_TEMPLATE_VIS not_equal_to<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS_ONLY greater : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TEMPLATE_VIS greater : binary_function<_Tp, _Tp, bool>
 {
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const

 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY greater<void>
+struct _LIBCPP_TEMPLATE_VIS greater<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS_ONLY greater_equal : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TEMPLATE_VIS greater_equal : binary_function<_Tp, _Tp, bool>
 {
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const

 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY greater_equal<void>
+struct _LIBCPP_TEMPLATE_VIS greater_equal<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS_ONLY less_equal : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TEMPLATE_VIS less_equal : binary_function<_Tp, _Tp, bool>
 {
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const

 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY less_equal<void>
+struct _LIBCPP_TEMPLATE_VIS less_equal<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS_ONLY logical_and : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TEMPLATE_VIS logical_and : binary_function<_Tp, _Tp, bool>
 {
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const

 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY logical_and<void>
+struct _LIBCPP_TEMPLATE_VIS logical_and<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS_ONLY logical_or : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TEMPLATE_VIS logical_or : binary_function<_Tp, _Tp, bool>
 {
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const

 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY logical_or<void>
+struct _LIBCPP_TEMPLATE_VIS logical_or<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS_ONLY logical_not : unary_function<_Tp, bool>
+struct _LIBCPP_TEMPLATE_VIS logical_not : unary_function<_Tp, bool>
 {
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x) const

 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY logical_not<void>
+struct _LIBCPP_TEMPLATE_VIS logical_not<void>
 {
     template <class _Tp>
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS_ONLY bit_and : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TEMPLATE_VIS bit_and : binary_function<_Tp, _Tp, _Tp>
 {
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const

 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY bit_and<void>
+struct _LIBCPP_TEMPLATE_VIS bit_and<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS_ONLY bit_or : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TEMPLATE_VIS bit_or : binary_function<_Tp, _Tp, _Tp>
 {
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const

 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY bit_or<void>
+struct _LIBCPP_TEMPLATE_VIS bit_or<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS_ONLY bit_xor : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TEMPLATE_VIS bit_xor : binary_function<_Tp, _Tp, _Tp>
 {
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const

 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY bit_xor<void>
+struct _LIBCPP_TEMPLATE_VIS bit_xor<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
-struct _LIBCPP_TYPE_VIS_ONLY bit_not : unary_function<_Tp, _Tp>
+struct _LIBCPP_TEMPLATE_VIS bit_not : unary_function<_Tp, _Tp>
 {
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const

 };
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY bit_not<void>
+struct _LIBCPP_TEMPLATE_VIS bit_not<void>
 {
     template <class _Tp>
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

 #endif
 
 template <class _Predicate>
-class _LIBCPP_TYPE_VIS_ONLY unary_negate
+class _LIBCPP_TEMPLATE_VIS unary_negate
     : public unary_function<typename _Predicate::argument_type, bool>
 {
     _Predicate __pred_;

 not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);}
 
 template <class _Predicate>
-class _LIBCPP_TYPE_VIS_ONLY binary_negate
+class _LIBCPP_TEMPLATE_VIS binary_negate
     : public binary_function<typename _Predicate::first_argument_type,
                              typename _Predicate::second_argument_type,
                              bool>

 not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);}
 
 template <class __Operation>
-class _LIBCPP_TYPE_VIS_ONLY binder1st
+class _LIBCPP_TEMPLATE_VIS binder1st
     : public unary_function<typename __Operation::second_argument_type,
                             typename __Operation::result_type>
 {

     {return binder1st<__Operation>(__op, __x);}
 
 template <class __Operation>
-class _LIBCPP_TYPE_VIS_ONLY binder2nd
+class _LIBCPP_TEMPLATE_VIS binder2nd
     : public unary_function<typename __Operation::first_argument_type,
                             typename __Operation::result_type>
 {

     {return binder2nd<__Operation>(__op, __x);}
 
 template <class _Arg, class _Result>
-class _LIBCPP_TYPE_VIS_ONLY pointer_to_unary_function
+class _LIBCPP_TEMPLATE_VIS pointer_to_unary_function
     : public unary_function<_Arg, _Result>
 {
     _Result (*__f_)(_Arg);

     {return pointer_to_unary_function<_Arg,_Result>(__f);}
 
 template <class _Arg1, class _Arg2, class _Result>
-class _LIBCPP_TYPE_VIS_ONLY pointer_to_binary_function
+class _LIBCPP_TEMPLATE_VIS pointer_to_binary_function
     : public binary_function<_Arg1, _Arg2, _Result>
 {
     _Result (*__f_)(_Arg1, _Arg2);

     {return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__f);}
 
 template<class _Sp, class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY mem_fun_t : public unary_function<_Tp*, _Sp>
+class _LIBCPP_TEMPLATE_VIS mem_fun_t : public unary_function<_Tp*, _Sp>
 {
     _Sp (_Tp::*__p_)();
 public:

 };
 
 template<class _Sp, class _Tp, class _Ap>
-class _LIBCPP_TYPE_VIS_ONLY mem_fun1_t : public binary_function<_Tp*, _Ap, _Sp>
+class _LIBCPP_TEMPLATE_VIS mem_fun1_t : public binary_function<_Tp*, _Ap, _Sp>
 {
     _Sp (_Tp::*__p_)(_Ap);
 public:

     {return mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
 
 template<class _Sp, class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY mem_fun_ref_t : public unary_function<_Tp, _Sp>
+class _LIBCPP_TEMPLATE_VIS mem_fun_ref_t : public unary_function<_Tp, _Sp>
 {
     _Sp (_Tp::*__p_)();
 public:

 };
 
 template<class _Sp, class _Tp, class _Ap>
-class _LIBCPP_TYPE_VIS_ONLY mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp>
+class _LIBCPP_TEMPLATE_VIS mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp>
 {
     _Sp (_Tp::*__p_)(_Ap);
 public:

     {return mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}
 
 template <class _Sp, class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY const_mem_fun_t : public unary_function<const _Tp*, _Sp>
+class _LIBCPP_TEMPLATE_VIS const_mem_fun_t : public unary_function<const _Tp*, _Sp>
 {
     _Sp (_Tp::*__p_)() const;
 public:

 };
 
 template <class _Sp, class _Tp, class _Ap>
-class _LIBCPP_TYPE_VIS_ONLY const_mem_fun1_t : public binary_function<const _Tp*, _Ap, _Sp>
+class _LIBCPP_TEMPLATE_VIS const_mem_fun1_t : public binary_function<const _Tp*, _Ap, _Sp>
 {
     _Sp (_Tp::*__p_)(_Ap) const;
 public:

     {return const_mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
 
 template <class _Sp, class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY const_mem_fun_ref_t : public unary_function<_Tp, _Sp>
+class _LIBCPP_TEMPLATE_VIS const_mem_fun_ref_t : public unary_function<_Tp, _Sp>
 {
     _Sp (_Tp::*__p_)() const;
 public:

 };
 
 template <class _Sp, class _Tp, class _Ap>
-class _LIBCPP_TYPE_VIS_ONLY const_mem_fun1_ref_t
+class _LIBCPP_TEMPLATE_VIS const_mem_fun1_ref_t
     : public binary_function<_Tp, _Ap, _Sp>
 {
     _Sp (_Tp::*__p_)(_Ap) const;

 {
 };
 
-template<class _Fp> class _LIBCPP_TYPE_VIS_ONLY function; // undefined
+template<class _Fp> class _LIBCPP_TEMPLATE_VIS function; // undefined
 
 namespace __function
 {

 }  // __function
 
 template<class _Rp, class ..._ArgTypes>
-class _LIBCPP_TYPE_VIS_ONLY function<_Rp(_ArgTypes...)>
+class _LIBCPP_TEMPLATE_VIS function<_Rp(_ArgTypes...)>
     : public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>,
       public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)>
 {

 {return __x.swap(__y);}
 
 template<class _Tp> struct __is_bind_expression : public false_type {};
-template<class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_bind_expression
+template<class _Tp> struct _LIBCPP_TEMPLATE_VIS is_bind_expression
     : public __is_bind_expression<typename remove_cv<_Tp>::type> {};
 
 template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {};
-template<class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_placeholder
+template<class _Tp> struct _LIBCPP_TEMPLATE_VIS is_placeholder
     : public __is_placeholder<typename remove_cv<_Tp>::type> {};
 
 namespace placeholders

 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY hash<bool>
+struct _LIBCPP_TEMPLATE_VIS hash<bool>
     : public unary_function<bool, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

 };
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY hash<char>
+struct _LIBCPP_TEMPLATE_VIS hash<char>
     : public unary_function<char, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

 };
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY hash<signed char>
+struct _LIBCPP_TEMPLATE_VIS hash<signed char>
     : public unary_function<signed char, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

 };
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned char>
+struct _LIBCPP_TEMPLATE_VIS hash<unsigned char>
     : public unary_function<unsigned char, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY hash<char16_t>
+struct _LIBCPP_TEMPLATE_VIS hash<char16_t>
     : public unary_function<char16_t, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

 };
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY hash<char32_t>
+struct _LIBCPP_TEMPLATE_VIS hash<char32_t>
     : public unary_function<char32_t, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY hash<wchar_t>
+struct _LIBCPP_TEMPLATE_VIS hash<wchar_t>
     : public unary_function<wchar_t, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

 };
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY hash<short>
+struct _LIBCPP_TEMPLATE_VIS hash<short>
     : public unary_function<short, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

 };
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned short>
+struct _LIBCPP_TEMPLATE_VIS hash<unsigned short>
     : public unary_function<unsigned short, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

 };
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY hash<int>
+struct _LIBCPP_TEMPLATE_VIS hash<int>
     : public unary_function<int, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

 };
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned int>
+struct _LIBCPP_TEMPLATE_VIS hash<unsigned int>
     : public unary_function<unsigned int, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

 };
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY hash<long>
+struct _LIBCPP_TEMPLATE_VIS hash<long>
     : public unary_function<long, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

 };
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned long>
+struct _LIBCPP_TEMPLATE_VIS hash<unsigned long>
     : public unary_function<unsigned long, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

 };
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY hash<long long>
+struct _LIBCPP_TEMPLATE_VIS hash<long long>
     : public __scalar_hash<long long>
 {
 };
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned long long>
+struct _LIBCPP_TEMPLATE_VIS hash<unsigned long long>
     : public __scalar_hash<unsigned long long>
 {
 };
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY hash<float>
+struct _LIBCPP_TEMPLATE_VIS hash<float>
     : public __scalar_hash<float>
 {
     _LIBCPP_INLINE_VISIBILITY

 };
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY hash<double>
+struct _LIBCPP_TEMPLATE_VIS hash<double>
     : public __scalar_hash<double>
 {
     _LIBCPP_INLINE_VISIBILITY

 };
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY hash<long double>
+struct _LIBCPP_TEMPLATE_VIS hash<long double>
     : public __scalar_hash<long double>
 {
     _LIBCPP_INLINE_VISIBILITY

 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY hash
+struct _LIBCPP_TEMPLATE_VIS hash
     : public unary_function<_Tp, size_t>
 {
     static_assert(is_enum<_Tp>::value, "This hash only works for enumeration types");

include/future

 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_errc)
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY is_error_code_enum<future_errc> : public true_type {};
+struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<future_errc> : public true_type {};
 
 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY is_error_code_enum<future_errc::__lx> : public true_type { };
+struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<future_errc::__lx> : public true_type { };
 #endif
 
 //enum class launch

     base::__on_zero_shared();
 }
 
-template <class _Rp> class _LIBCPP_TYPE_VIS_ONLY promise;
-template <class _Rp> class _LIBCPP_TYPE_VIS_ONLY shared_future;
+template <class _Rp> class _LIBCPP_TEMPLATE_VIS promise;
+template <class _Rp> class _LIBCPP_TEMPLATE_VIS shared_future;
 
 // future
 
-template <class _Rp> class _LIBCPP_TYPE_VIS_ONLY future;
+template <class _Rp> class _LIBCPP_TEMPLATE_VIS future;
 
 template <class _Rp, class _Fp>
 future<_Rp>

 #endif
 
 template <class _Rp>
-class _LIBCPP_TYPE_VIS_ONLY future
+class _LIBCPP_TEMPLATE_VIS future
 {
     __assoc_state<_Rp>* __state_;
 

 }
 
 template <class _Rp>
-class _LIBCPP_TYPE_VIS_ONLY future<_Rp&>
+class _LIBCPP_TEMPLATE_VIS future<_Rp&>
 {
     __assoc_state<_Rp&>* __state_;
 

 template <class _Callable> class packaged_task;
 
 template <class _Rp>
-class _LIBCPP_TYPE_VIS_ONLY promise
+class _LIBCPP_TEMPLATE_VIS promise
 {
     __assoc_state<_Rp>* __state_;
 

 // promise<R&>
 
 template <class _Rp>
-class _LIBCPP_TYPE_VIS_ONLY promise<_Rp&>
+class _LIBCPP_TEMPLATE_VIS promise<_Rp&>
 {
     __assoc_state<_Rp&>* __state_;
 

 }
 
 template <class _Rp, class _Alloc>
-    struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<promise<_Rp>, _Alloc>
+    struct _LIBCPP_TEMPLATE_VIS uses_allocator<promise<_Rp>, _Alloc>
         : public true_type {};
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS

 }
 
 template<class _Rp, class ..._ArgTypes>
-class _LIBCPP_TYPE_VIS_ONLY packaged_task<_Rp(_ArgTypes...)>
+class _LIBCPP_TEMPLATE_VIS packaged_task<_Rp(_ArgTypes...)>
 {
 public:
     typedef _Rp result_type;

 }
 
 template<class ..._ArgTypes>
-class _LIBCPP_TYPE_VIS_ONLY packaged_task<void(_ArgTypes...)>
+class _LIBCPP_TEMPLATE_VIS packaged_task<void(_ArgTypes...)>
 {
 public:
     typedef void result_type;

 }
 
 template <class _Callable, class _Alloc>
-struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<packaged_task<_Callable>, _Alloc>
+struct _LIBCPP_TEMPLATE_VIS uses_allocator<packaged_task<_Callable>, _Alloc>
     : public true_type {};
 
 template <class _Rp, class _Fp>

 // shared_future
 
 template <class _Rp>
-class _LIBCPP_TYPE_VIS_ONLY shared_future
+class _LIBCPP_TEMPLATE_VIS shared_future
 {
     __assoc_state<_Rp>* __state_;
 

 }
 
 template <class _Rp>
-class _LIBCPP_TYPE_VIS_ONLY shared_future<_Rp&>
+class _LIBCPP_TEMPLATE_VIS shared_future<_Rp&>
 {
     __assoc_state<_Rp&>* __state_;
 

include/initializer_list

 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 template<class _Ep>
-class _LIBCPP_TYPE_VIS_ONLY initializer_list
+class _LIBCPP_TEMPLATE_VIS initializer_list
 {
     const _Ep* __begin_;
     size_t    __size_;

include/ios

 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(io_errc)
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY is_error_code_enum<io_errc> : public true_type { };
+struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc> : public true_type { };
 
 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY is_error_code_enum<io_errc::__lx> : public true_type { };
+struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc::__lx> : public true_type { };
 #endif
 
 _LIBCPP_FUNC_VIS

 }
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS_ONLY basic_ios
+class _LIBCPP_TEMPLATE_VIS basic_ios
     : public ios_base
 {
 public:

include/iosfwd

 
 class _LIBCPP_TYPE_VIS ios_base;
 
-template<class _CharT>  struct _LIBCPP_TYPE_VIS_ONLY char_traits;
-template<class _Tp>     class _LIBCPP_TYPE_VIS_ONLY allocator;
+template<class _CharT>  struct _LIBCPP_TEMPLATE_VIS char_traits;
+template<class _Tp>     class _LIBCPP_TEMPLATE_VIS allocator;
 
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS_ONLY basic_ios;
+    class _LIBCPP_TEMPLATE_VIS basic_ios;
 
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS_ONLY basic_streambuf;
+    class _LIBCPP_TEMPLATE_VIS basic_streambuf;
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS_ONLY basic_istream;
+    class _LIBCPP_TEMPLATE_VIS basic_istream;
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS_ONLY basic_ostream;
+    class _LIBCPP_TEMPLATE_VIS basic_ostream;
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS_ONLY basic_iostream;
+    class _LIBCPP_TEMPLATE_VIS basic_iostream;
 
 template <class _CharT, class _Traits = char_traits<_CharT>,
           class _Allocator = allocator<_CharT> >
-    class _LIBCPP_TYPE_VIS_ONLY basic_stringbuf;
+    class _LIBCPP_TEMPLATE_VIS basic_stringbuf;
 template <class _CharT, class _Traits = char_traits<_CharT>,
           class _Allocator = allocator<_CharT> >
-    class _LIBCPP_TYPE_VIS_ONLY basic_istringstream;
+    class _LIBCPP_TEMPLATE_VIS basic_istringstream;
 template <class _CharT, class _Traits = char_traits<_CharT>,
           class _Allocator = allocator<_CharT> >
-    class _LIBCPP_TYPE_VIS_ONLY basic_ostringstream;
+    class _LIBCPP_TEMPLATE_VIS basic_ostringstream;
 template <class _CharT, class _Traits = char_traits<_CharT>,
           class _Allocator = allocator<_CharT> >
-    class _LIBCPP_TYPE_VIS_ONLY basic_stringstream;
+    class _LIBCPP_TEMPLATE_VIS basic_stringstream;
 
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS_ONLY basic_filebuf;
+    class _LIBCPP_TEMPLATE_VIS basic_filebuf;
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS_ONLY basic_ifstream;
+    class _LIBCPP_TEMPLATE_VIS basic_ifstream;
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS_ONLY basic_ofstream;
+    class _LIBCPP_TEMPLATE_VIS basic_ofstream;
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS_ONLY basic_fstream;
+    class _LIBCPP_TEMPLATE_VIS basic_fstream;
 
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS_ONLY istreambuf_iterator;
+    class _LIBCPP_TEMPLATE_VIS istreambuf_iterator;
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS_ONLY ostreambuf_iterator;
+    class _LIBCPP_TEMPLATE_VIS ostreambuf_iterator;
 
 typedef basic_ios<char>              ios;
 typedef basic_ios<wchar_t>           wios;

 typedef basic_ofstream<wchar_t>      wofstream;
 typedef basic_fstream<wchar_t>       wfstream;
 
-template <class _State>             class _LIBCPP_TYPE_VIS_ONLY fpos;
+template <class _State>             class _LIBCPP_TEMPLATE_VIS fpos;
 typedef fpos<mbstate_t>    streampos;
 typedef fpos<mbstate_t>    wstreampos;
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS

 template <class _CharT,             // for <stdexcept>
           class _Traits = char_traits<_CharT>,
           class _Allocator = allocator<_CharT> >
-    class _LIBCPP_TYPE_VIS_ONLY basic_string;
+    class _LIBCPP_TEMPLATE_VIS basic_string;
 typedef basic_string<char, char_traits<char>, allocator<char> > string;
 typedef basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > wstring;
 

include/istream

 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS_ONLY basic_istream
+class _LIBCPP_TEMPLATE_VIS basic_istream
     : virtual public basic_ios<_CharT, _Traits>
 {
     streamsize __gc_;

 public:
 
     // 27.7.1.1.3 Prefix/suffix:
-    class _LIBCPP_TYPE_VIS_ONLY sentry;
+    class _LIBCPP_TEMPLATE_VIS sentry;
 
     // 27.7.1.2 Formatted input:
     basic_istream& operator>>(basic_istream& (*__pf)(basic_istream&));

 };
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS_ONLY basic_istream<_CharT, _Traits>::sentry
+class _LIBCPP_TEMPLATE_VIS basic_istream<_CharT, _Traits>::sentry
 {
     bool __ok_;
 

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS_ONLY basic_iostream
+class _LIBCPP_TEMPLATE_VIS basic_iostream
     : public basic_istream<_CharT, _Traits>,
       public basic_ostream<_CharT, _Traits>
 {

include/iterator

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-struct _LIBCPP_TYPE_VIS_ONLY input_iterator_tag {};
-struct _LIBCPP_TYPE_VIS_ONLY output_iterator_tag {};
-struct _LIBCPP_TYPE_VIS_ONLY forward_iterator_tag       : public input_iterator_tag {};
-struct _LIBCPP_TYPE_VIS_ONLY bidirectional_iterator_tag : public forward_iterator_tag {};
-struct _LIBCPP_TYPE_VIS_ONLY random_access_iterator_tag : public bidirectional_iterator_tag {};
+struct _LIBCPP_TEMPLATE_VIS input_iterator_tag {};
+struct _LIBCPP_TEMPLATE_VIS output_iterator_tag {};
+struct _LIBCPP_TEMPLATE_VIS forward_iterator_tag       : public input_iterator_tag {};
+struct _LIBCPP_TEMPLATE_VIS bidirectional_iterator_tag : public forward_iterator_tag {};
+struct _LIBCPP_TEMPLATE_VIS random_access_iterator_tag : public bidirectional_iterator_tag {};
 
 template <class _Tp>
 struct __has_iterator_category

 //    the client expects instead of failing at compile time.
 
 template <class _Iter>
-struct _LIBCPP_TYPE_VIS_ONLY iterator_traits
+struct _LIBCPP_TEMPLATE_VIS iterator_traits
     : __iterator_traits<_Iter, __has_iterator_category<_Iter>::value> {};
 
 template<class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY iterator_traits<_Tp*>
+struct _LIBCPP_TEMPLATE_VIS iterator_traits<_Tp*>
 {
     typedef ptrdiff_t difference_type;
     typedef typename remove_const<_Tp>::type value_type;

 
 template<class _Category, class _Tp, class _Distance = ptrdiff_t,
          class _Pointer = _Tp*, class _Reference = _Tp&>
-struct _LIBCPP_TYPE_VIS_ONLY iterator
+struct _LIBCPP_TEMPLATE_VIS iterator
 {
     typedef _Tp        value_type;
     typedef _Distance  difference_type;

 }
 
 template <class _Iter>
-class _LIBCPP_TYPE_VIS_ONLY reverse_iterator
+class _LIBCPP_TEMPLATE_VIS reverse_iterator
     : public iterator<typename iterator_traits<_Iter>::iterator_category,
                       typename iterator_traits<_Iter>::value_type,
                       typename iterator_traits<_Iter>::difference_type,

 #endif
 
 template <class _Container>
-class _LIBCPP_TYPE_VIS_ONLY back_insert_iterator
+class _LIBCPP_TEMPLATE_VIS back_insert_iterator
     : public iterator<output_iterator_tag,
                       void,
                       void,

 }
 
 template <class _Container>
-class _LIBCPP_TYPE_VIS_ONLY front_insert_iterator
+class _LIBCPP_TEMPLATE_VIS front_insert_iterator
     : public iterator<output_iterator_tag,
                       void,
                       void,

 }
 
 template <class _Container>
-class _LIBCPP_TYPE_VIS_ONLY insert_iterator
+class _LIBCPP_TEMPLATE_VIS insert_iterator
     : public iterator<output_iterator_tag,
                       void,
                       void,

 
 template <class _Tp, class _CharT = char,
           class _Traits = char_traits<_CharT>, class _Distance = ptrdiff_t>
-class _LIBCPP_TYPE_VIS_ONLY istream_iterator
+class _LIBCPP_TEMPLATE_VIS istream_iterator
     : public iterator<input_iterator_tag, _Tp, _Distance, const _Tp*, const _Tp&>
 {
 public:

 };
 
 template <class _Tp, class _CharT = char, class _Traits = char_traits<_CharT> >
-class _LIBCPP_TYPE_VIS_ONLY ostream_iterator
+class _LIBCPP_TEMPLATE_VIS ostream_iterator
     : public iterator<output_iterator_tag, void, void, void, void>
 {
 public:

 };
 
 template<class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS_ONLY istreambuf_iterator
+class _LIBCPP_TEMPLATE_VIS istreambuf_iterator
     : public iterator<input_iterator_tag, _CharT,
                       typename _Traits::off_type, _CharT*,
                       _CharT>

                 {return !__a.equal(__b);}
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS_ONLY ostreambuf_iterator
+class _LIBCPP_TEMPLATE_VIS ostreambuf_iterator
     : public iterator<output_iterator_tag, void, void, void, void>
 {
 public:

 };
 
 template <class _Iter>
-class _LIBCPP_TYPE_VIS_ONLY move_iterator
+class _LIBCPP_TEMPLATE_VIS move_iterator
 {
 private:
     _Iter __i;

include/limits

 };
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY numeric_limits
+class _LIBCPP_TEMPLATE_VIS numeric_limits
     : private __libcpp_numeric_limits<typename remove_cv<_Tp>::type>
 {
     typedef __libcpp_numeric_limits<typename remove_cv<_Tp>::type> __base;

     _LIBCPP_CONSTEXPR const float_round_style numeric_limits<_Tp>::round_style;
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY numeric_limits<const _Tp>
+class _LIBCPP_TEMPLATE_VIS numeric_limits<const _Tp>
     : private numeric_limits<_Tp>
 {
     typedef numeric_limits<_Tp> __base;

     _LIBCPP_CONSTEXPR const float_round_style numeric_limits<const _Tp>::round_style;
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY numeric_limits<volatile _Tp>
+class _LIBCPP_TEMPLATE_VIS numeric_limits<volatile _Tp>
     : private numeric_limits<_Tp>
 {
     typedef numeric_limits<_Tp> __base;

     _LIBCPP_CONSTEXPR const float_round_style numeric_limits<volatile _Tp>::round_style;
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY numeric_limits<const volatile _Tp>
+class _LIBCPP_TEMPLATE_VIS numeric_limits<const volatile _Tp>
     : private numeric_limits<_Tp>
 {
     typedef numeric_limits<_Tp> __base;

include/list

     _Tp __value_;
 };
 
-template <class _Tp, class _Alloc> class _LIBCPP_TYPE_VIS_ONLY list;
+template <class _Tp, class _Alloc> class _LIBCPP_TEMPLATE_VIS list;
 template <class _Tp, class _Alloc> class __list_imp;
-template <class _Tp, class _VoidPtr> class _LIBCPP_TYPE_VIS_ONLY __list_const_iterator;
+template <class _Tp, class _VoidPtr> class _LIBCPP_TEMPLATE_VIS __list_const_iterator;
 
 template <class _Tp, class _VoidPtr>
-class _LIBCPP_TYPE_VIS_ONLY __list_iterator
+class _LIBCPP_TEMPLATE_VIS __list_iterator
 {
     typedef typename pointer_traits<_VoidPtr>::template
 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES

 };
 
 template <class _Tp, class _VoidPtr>
-class _LIBCPP_TYPE_VIS_ONLY __list_const_iterator
+class _LIBCPP_TEMPLATE_VIS __list_const_iterator
 {
     typedef typename pointer_traits<_VoidPtr>::template
 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES

 }
 
 template <class _Tp, class _Alloc = allocator<_Tp> >
-class _LIBCPP_TYPE_VIS_ONLY list
+class _LIBCPP_TEMPLATE_VIS list
     : private __list_imp<_Tp, _Alloc>
 {
     typedef __list_imp<_Tp, _Alloc> base;

include/locale

 _LIBCPP_EXTERN_TEMPLATE2(struct _LIBCPP_TYPE_VIS __num_get<wchar_t>)
 
 template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
-class _LIBCPP_TYPE_VIS_ONLY num_get
+class _LIBCPP_TEMPLATE_VIS num_get
     : public locale::facet,
       private __num_get<_CharT>
 {

 _LIBCPP_EXTERN_TEMPLATE2(struct _LIBCPP_TYPE_VIS __num_put<wchar_t>)
 
 template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
-class _LIBCPP_TYPE_VIS_ONLY num_put
+class _LIBCPP_TEMPLATE_VIS num_put
     : public locale::facet,
       private __num_put<_CharT>
 {

 };
 
 template <class _CharT>
-class _LIBCPP_TYPE_VIS_ONLY __time_get_c_storage
+class _LIBCPP_TEMPLATE_VIS __time_get_c_storage
 {
 protected:
     typedef basic_string<_CharT> string_type;

 };
 
 template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
-class _LIBCPP_TYPE_VIS_ONLY time_get
+class _LIBCPP_TEMPLATE_VIS time_get
     : public locale::facet,
       public time_base,
       private __time_get_c_storage<_CharT>

 };
 
 template <class _CharT>
-class _LIBCPP_TYPE_VIS_ONLY __time_get_storage
+class _LIBCPP_TEMPLATE_VIS __time_get_storage
     : public __time_get
 {
 protected:

 };
 
 template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
-class _LIBCPP_TYPE_VIS_ONLY time_get_byname
+class _LIBCPP_TEMPLATE_VIS time_get_byname
     : public time_get<_CharT, _InputIterator>,
       private __time_get_storage<_CharT>
 {

 };
 
 template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
-class _LIBCPP_TYPE_VIS_ONLY time_put
+class _LIBCPP_TEMPLATE_VIS time_put
     : public locale::facet,
       private __time_put
 {

 _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS time_put<wchar_t>)
 
 template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
-class _LIBCPP_TYPE_VIS_ONLY time_put_byname
+class _LIBCPP_TEMPLATE_VIS time_put_byname
     : public time_put<_CharT, _OutputIterator>
 {
 public:

 // moneypunct
 
 template <class _CharT, bool _International = false>
-class _LIBCPP_TYPE_VIS_ONLY moneypunct
+class _LIBCPP_TEMPLATE_VIS moneypunct
     : public locale::facet,
       public money_base
 {

 // moneypunct_byname
 
 template <class _CharT, bool _International = false>
-class _LIBCPP_TYPE_VIS_ONLY moneypunct_byname
+class _LIBCPP_TEMPLATE_VIS moneypunct_byname
     : public moneypunct<_CharT, _International>
 {
 public:

 _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS __money_get<wchar_t>)
 
 template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
-class _LIBCPP_TYPE_VIS_ONLY money_get
+class _LIBCPP_TEMPLATE_VIS money_get
     : public locale::facet,
       private __money_get<_CharT>
 {

 _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS __money_put<wchar_t>)
 
 template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
-class _LIBCPP_TYPE_VIS_ONLY money_put
+class _LIBCPP_TEMPLATE_VIS money_put
     : public locale::facet,
       private __money_put<_CharT>
 {

 };
 
 template <class _CharT>
-class _LIBCPP_TYPE_VIS_ONLY messages
+class _LIBCPP_TEMPLATE_VIS messages
     : public locale::facet,
       public messages_base
 {

 _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS messages<wchar_t>)
 
 template <class _CharT>
-class _LIBCPP_TYPE_VIS_ONLY messages_byname
+class _LIBCPP_TEMPLATE_VIS messages_byname
     : public messages<_CharT>
 {
 public:

 template<class _Codecvt, class _Elem = wchar_t,
          class _Wide_alloc = allocator<_Elem>,
          class _Byte_alloc = allocator<char> >
-class _LIBCPP_TYPE_VIS_ONLY wstring_convert
+class _LIBCPP_TEMPLATE_VIS wstring_convert
 {
 public:
     typedef basic_string<char, char_traits<char>, _Byte_alloc>   byte_string;

 }
 
 template <class _Codecvt, class _Elem = wchar_t, class _Tr = char_traits<_Elem> >
-class _LIBCPP_TYPE_VIS_ONLY wbuffer_convert
+class _LIBCPP_TEMPLATE_VIS wbuffer_convert
     : public basic_streambuf<_Elem, _Tr>
 {
 public:

include/map

 #endif
 
 template <class _TreeIterator>
-class _LIBCPP_TYPE_VIS_ONLY __map_iterator
+class _LIBCPP_TEMPLATE_VIS __map_iterator
 {
     _TreeIterator __i_;
 

     bool operator!=(const __map_iterator& __x, const __map_iterator& __y)
         {return __x.__i_ != __y.__i_;}
 
-    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY map;
-    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY multimap;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __map_const_iterator;
+    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
+    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS __map_const_iterator;
 };
 
 template <class _TreeIterator>
-class _LIBCPP_TYPE_VIS_ONLY __map_const_iterator
+class _LIBCPP_TEMPLATE_VIS __map_const_iterator
 {
     _TreeIterator __i_;
 

     bool operator!=(const __map_const_iterator& __x, const __map_const_iterator& __y)
         {return __x.__i_ != __y.__i_;}
 
-    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY map;
-    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY multimap;
-    template <class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY __tree_const_iterator;
+    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
+    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
+    template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS __tree_const_iterator;
 };
 
 template <class _Key, class _Tp, class _Compare = less<_Key>,
           class _Allocator = allocator<pair<const _Key, _Tp> > >
-class _LIBCPP_TYPE_VIS_ONLY map
+class _LIBCPP_TEMPLATE_VIS map
 {
 public:
     // types:

     typedef value_type&                              reference;
     typedef const value_type&                        const_reference;
 
-    class _LIBCPP_TYPE_VIS_ONLY value_compare
+    class _LIBCPP_TEMPLATE_VIS value_compare
         : public binary_function<value_type, value_type, bool>
     {
         friend class map;

 
 template <class _Key, class _Tp, class _Compare = less<_Key>,
           class _Allocator = allocator<pair<const _Key, _Tp> > >
-class _LIBCPP_TYPE_VIS_ONLY multimap
+class _LIBCPP_TEMPLATE_VIS multimap
 {
 public:
     // types:

     typedef value_type&                              reference;
     typedef const value_type&                        const_reference;
 
-    class _LIBCPP_TYPE_VIS_ONLY value_compare
+    class _LIBCPP_TEMPLATE_VIS value_compare
         : public binary_function<value_type, value_type, bool>
     {
         friend class multimap;

include/memory

 template <class _Tp> class allocator;
 
 template <>
-class _LIBCPP_TYPE_VIS_ONLY allocator<void>
+class _LIBCPP_TEMPLATE_VIS allocator<void>
 {
 public:
     typedef void*             pointer;

 };
 
 template <>
-class _LIBCPP_TYPE_VIS_ONLY allocator<const void>
+class _LIBCPP_TEMPLATE_VIS allocator<const void>
 {
 public:
     typedef const void*       pointer;

 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
 template <class _Ptr>
-struct _LIBCPP_TYPE_VIS_ONLY pointer_traits
+struct _LIBCPP_TEMPLATE_VIS pointer_traits
 {
     typedef _Ptr                                                     pointer;
     typedef typename __pointer_traits_element_type<pointer>::type    element_type;

 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY pointer_traits<_Tp*>
+struct _LIBCPP_TEMPLATE_VIS pointer_traits<_Tp*>
 {
     typedef _Tp*      pointer;
     typedef _Tp       element_type;

 };
 
 template <class _Alloc>
-struct _LIBCPP_TYPE_VIS_ONLY allocator_traits
+struct _LIBCPP_TEMPLATE_VIS allocator_traits
 {
     typedef _Alloc                              allocator_type;
     typedef typename allocator_type::value_type value_type;

 // allocator
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY allocator
+class _LIBCPP_TEMPLATE_VIS allocator
 {
 public:
     typedef size_t            size_type;

 };
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY allocator<const _Tp>
+class _LIBCPP_TEMPLATE_VIS allocator<const _Tp>
 {
 public:
     typedef size_t            size_type;

 bool operator!=(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return false;}
 
 template <class _OutputIterator, class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY raw_storage_iterator
+class _LIBCPP_TEMPLATE_VIS raw_storage_iterator
     : public iterator<output_iterator_tag,
                       _Tp,                                         // purposefully not C++03
                       ptrdiff_t,                                   // purposefully not C++03

 };
 
 template<class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY auto_ptr
+class _LIBCPP_TEMPLATE_VIS auto_ptr
 {
 private:
     _Tp* __ptr_;

 };
 
 template <>
-class _LIBCPP_TYPE_VIS_ONLY auto_ptr<void>
+class _LIBCPP_TEMPLATE_VIS auto_ptr<void>
 {
 public:
     typedef void element_type;

 // default_delete
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY default_delete
+struct _LIBCPP_TEMPLATE_VIS default_delete
 {
 #ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR default_delete() _NOEXCEPT = default;

 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY default_delete<_Tp[]>
+struct _LIBCPP_TEMPLATE_VIS default_delete<_Tp[]>
 {
 public:
 #ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS

 };
 
 template <class _Tp, class _Dp = default_delete<_Tp> >
-class _LIBCPP_TYPE_VIS_ONLY unique_ptr
+class _LIBCPP_TEMPLATE_VIS unique_ptr
 {
 public:
     typedef _Tp element_type;

 };
 
 template <class _Tp, class _Dp>
-class _LIBCPP_TYPE_VIS_ONLY unique_ptr<_Tp[], _Dp>
+class _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp>
 {
 public:
     typedef _Tp element_type;

 };
 
 template<class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY hash<_Tp*>
+struct _LIBCPP_TEMPLATE_VIS hash<_Tp*>
     : public unary_function<_Tp*, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

 };
 
 template <class _Tp, class _Dp>
-struct _LIBCPP_TYPE_VIS_ONLY hash<unique_ptr<_Tp, _Dp> >
+struct _LIBCPP_TEMPLATE_VIS hash<unique_ptr<_Tp, _Dp> >
 {
     typedef unique_ptr<_Tp, _Dp> argument_type;
     typedef size_t               result_type;

     virtual const char* what() const  _NOEXCEPT;
 };
 
-template<class _Tp> class _LIBCPP_TYPE_VIS_ONLY weak_ptr;
+template<class _Tp> class _LIBCPP_TEMPLATE_VIS weak_ptr;
 
 class _LIBCPP_TYPE_VIS __shared_count
 {

     __a.deallocate(this, 1);
 }
 
-template<class _Tp> class _LIBCPP_TYPE_VIS_ONLY enable_shared_from_this;
+template<class _Tp> class _LIBCPP_TEMPLATE_VIS enable_shared_from_this;
 
 template<class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY shared_ptr
+class _LIBCPP_TEMPLATE_VIS shared_ptr
 {
 public:
     typedef _Tp element_type;

     _LIBCPP_INLINE_VISIBILITY
     void __enable_weak_this(const void*) _NOEXCEPT {}
 
-    template <class _Up> friend class _LIBCPP_TYPE_VIS_ONLY shared_ptr;
-    template <class _Up> friend class _LIBCPP_TYPE_VIS_ONLY weak_ptr;
+    template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr;
+    template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr;
 };
 
 template<class _Tp>

 #endif  // _LIBCPP_NO_RTTI
 
 template<class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY weak_ptr
+class _LIBCPP_TEMPLATE_VIS weak_ptr
 {
 public:
     typedef _Tp element_type;

         bool owner_before(const weak_ptr<_Up>& __r) const
         {return __cntrl_ < __r.__cntrl_;}
 
-    template <class _Up> friend class _LIBCPP_TYPE_VIS_ONLY weak_ptr;
-    template <class _Up> friend class _LIBCPP_TYPE_VIS_ONLY shared_ptr;
+    template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr;
+    template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr;
 };
 
 template<class _Tp>

 template <class _Tp> struct owner_less;
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY owner_less<shared_ptr<_Tp> >
+struct _LIBCPP_TEMPLATE_VIS owner_less<shared_ptr<_Tp> >
     : binary_function<shared_ptr<_Tp>, shared_ptr<_Tp>, bool>
 {
     typedef bool result_type;

 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY owner_less<weak_ptr<_Tp> >
+struct _LIBCPP_TEMPLATE_VIS owner_less<weak_ptr<_Tp> >
     : binary_function<weak_ptr<_Tp>, weak_ptr<_Tp>, bool>
 {
     typedef bool result_type;

 };
 
 template<class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY enable_shared_from_this
+class _LIBCPP_TEMPLATE_VIS enable_shared_from_this
 {
     mutable weak_ptr<_Tp> __weak_this_;
 protected:

 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY hash<shared_ptr<_Tp> >
+struct _LIBCPP_TEMPLATE_VIS hash<shared_ptr<_Tp> >
 {
     typedef shared_ptr<_Tp>      argument_type;
     typedef size_t               result_type;

include/mutex

 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
-struct _LIBCPP_TYPE_VIS_ONLY once_flag
+struct _LIBCPP_TYPE_VIS once_flag
 {
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR

include/ostream

 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS_ONLY basic_ostream
+class _LIBCPP_TEMPLATE_VIS basic_ostream
     : virtual public basic_ios<_CharT, _Traits>
 {
 public:

 public:
 
     // 27.7.2.4 Prefix/suffix:
-    class _LIBCPP_TYPE_VIS_ONLY sentry;
+    class _LIBCPP_TEMPLATE_VIS sentry;
 
     // 27.7.2.6 Formatted output:
     basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&));

 };
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS_ONLY basic_ostream<_CharT, _Traits>::sentry
+class _LIBCPP_TEMPLATE_VIS basic_ostream<_CharT, _Traits>::sentry
 {
     bool __ok_;
     basic_ostream<_CharT, _Traits>& __os_;

include/queue

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp, class _Container> class _LIBCPP_TYPE_VIS_ONLY queue;
+template <class _Tp, class _Container> class _LIBCPP_TEMPLATE_VIS queue;
 
 template <class _Tp, class _Container>
 _LIBCPP_INLINE_VISIBILITY

 operator< (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y);
 
 template <class _Tp, class _Container = deque<_Tp> >
-class _LIBCPP_TYPE_VIS_ONLY queue
+class _LIBCPP_TEMPLATE_VIS queue
 {
 public:
     typedef _Container                               container_type;

 }
 
 template <class _Tp, class _Container, class _Alloc>
-struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<queue<_Tp, _Container>, _Alloc>
+struct _LIBCPP_TEMPLATE_VIS uses_allocator<queue<_Tp, _Container>, _Alloc>
     : public uses_allocator<_Container, _Alloc>
 {
 };
 
 template <class _Tp, class _Container = vector<_Tp>,
           class _Compare = less<typename _Container::value_type> >
-class _LIBCPP_TYPE_VIS_ONLY priority_queue
+class _LIBCPP_TEMPLATE_VIS priority_queue
 {
 public:
     typedef _Container                               container_type;

 }
 
 template <class _Tp, class _Container, class _Compare, class _Alloc>
-struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<priority_queue<_Tp, _Container, _Compare>, _Alloc>
+struct _LIBCPP_TEMPLATE_VIS uses_allocator<priority_queue<_Tp, _Container, _Compare>, _Alloc>
     : public uses_allocator<_Container, _Alloc>
 {
 };

include/random

 };
 
 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-class _LIBCPP_TYPE_VIS_ONLY linear_congruential_engine;
+class _LIBCPP_TEMPLATE_VIS linear_congruential_engine;
 
 template <class _CharT, class _Traits,
           class _Up, _Up _Ap, _Up _Cp, _Up _Np>

            linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x);
 
 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-class _LIBCPP_TYPE_VIS_ONLY linear_congruential_engine
+class _LIBCPP_TEMPLATE_VIS linear_congruential_engine
 {
 public:
     // types

 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-class _LIBCPP_TYPE_VIS_ONLY mersenne_twister_engine;
+class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine;
 
 template <class _UI, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
           _UI _Ap, size_t _Up, _UI _Dp, size_t _Sp,

 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-class _LIBCPP_TYPE_VIS_ONLY mersenne_twister_engine
+class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine
 {
 public:
     // types

 // subtract_with_carry_engine
 
 template<class _UIntType, size_t __w, size_t __s, size_t __r>
-class _LIBCPP_TYPE_VIS_ONLY subtract_with_carry_engine;
+class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine;
 
 template<class _UI, size_t _Wp, size_t _Sp, size_t _Rp>
 bool

            subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __x);
 
 template<class _UIntType, size_t __w, size_t __s, size_t __r>
-class _LIBCPP_TYPE_VIS_ONLY subtract_with_carry_engine
+class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine
 {
 public:
     // types

 // discard_block_engine
 
 template<class _Engine, size_t __p, size_t __r>
-class _LIBCPP_TYPE_VIS_ONLY discard_block_engine
+class _LIBCPP_TEMPLATE_VIS discard_block_engine
 {
     _Engine __e_;
     int     __n_;

 // independent_bits_engine
 
 template<class _Engine, size_t __w, class _UIntType>
-class _LIBCPP_TYPE_VIS_ONLY independent_bits_engine
+class _LIBCPP_TEMPLATE_VIS independent_bits_engine
 {
     template <class _UI, _UI _R0, size_t _Wp, size_t _Mp>
     class __get_n

 };
 
 template<class _Engine, size_t __k>
-class _LIBCPP_TYPE_VIS_ONLY shuffle_order_engine
+class _LIBCPP_TEMPLATE_VIS shuffle_order_engine
 {
     static_assert(0 < __k, "shuffle_order_engine invalid parameters");
 public:

 // uniform_real_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS_ONLY uniform_real_distribution
+class _LIBCPP_TEMPLATE_VIS uniform_real_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS_ONLY param_type
+    class _LIBCPP_TEMPLATE_VIS param_type
     {
         result_type __a_;
         result_type __b_;

     // types
     typedef bool result_type;
 
-    class _LIBCPP_TYPE_VIS_ONLY param_type
+    class _LIBCPP_INLINE_VISIBILITY param_type
     {
         double __p_;
     public:

 // binomial_distribution
 
 template<class _IntType = int>
-class _LIBCPP_TYPE_VIS_ONLY binomial_distribution
+class _LIBCPP_TEMPLATE_VIS binomial_distribution
 {
 public:
     // types
     typedef _IntType result_type;
 
-    class _LIBCPP_TYPE_VIS_ONLY param_type
+    class _LIBCPP_TEMPLATE_VIS param_type
     {
         result_type __t_;
         double __p_;

 // exponential_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS_ONLY exponential_distribution
+class _LIBCPP_TEMPLATE_VIS exponential_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS_ONLY param_type
+    class _LIBCPP_TEMPLATE_VIS param_type
     {
         result_type __lambda_;
     public:

 // normal_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS_ONLY normal_distribution
+class _LIBCPP_TEMPLATE_VIS normal_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS_ONLY param_type
+    class _LIBCPP_TEMPLATE_VIS param_type
     {
         result_type __mean_;
         result_type __stddev_;

 // lognormal_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS_ONLY lognormal_distribution
+class _LIBCPP_TEMPLATE_VIS lognormal_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS_ONLY param_type
+    class _LIBCPP_TEMPLATE_VIS param_type
     {
         normal_distribution<result_type> __nd_;
     public:

 // poisson_distribution
 
 template<class _IntType = int>
-class _LIBCPP_TYPE_VIS_ONLY poisson_distribution
+class _LIBCPP_TEMPLATE_VIS poisson_distribution
 {
 public:
     // types
     typedef _IntType result_type;
 
-    class _LIBCPP_TYPE_VIS_ONLY param_type
+    class _LIBCPP_TEMPLATE_VIS param_type
     {
         double __mean_;
         double __s_;

 // weibull_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS_ONLY weibull_distribution
+class _LIBCPP_TEMPLATE_VIS weibull_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS_ONLY param_type
+    class _LIBCPP_TEMPLATE_VIS param_type
     {
         result_type __a_;
         result_type __b_;

 }
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS_ONLY extreme_value_distribution
+class _LIBCPP_TEMPLATE_VIS extreme_value_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS_ONLY param_type
+    class _LIBCPP_TEMPLATE_VIS param_type
     {
         result_type __a_;
         result_type __b_;

 // gamma_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS_ONLY gamma_distribution
+class _LIBCPP_TEMPLATE_VIS gamma_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS_ONLY param_type
+    class _LIBCPP_TEMPLATE_VIS param_type
     {
         result_type __alpha_;
         result_type __beta_;

 // negative_binomial_distribution
 
 template<class _IntType = int>
-class _LIBCPP_TYPE_VIS_ONLY negative_binomial_distribution
+class _LIBCPP_TEMPLATE_VIS negative_binomial_distribution
 {
 public:
     // types
     typedef _IntType result_type;
 
-    class _LIBCPP_TYPE_VIS_ONLY param_type
+    class _LIBCPP_TEMPLATE_VIS param_type
     {
         result_type __k_;
         double __p_;

 // geometric_distribution
 
 template<class _IntType = int>
-class _LIBCPP_TYPE_VIS_ONLY geometric_distribution
+class _LIBCPP_TEMPLATE_VIS geometric_distribution
 {
 public:
     // types
     typedef _IntType result_type;
 
-    class _LIBCPP_TYPE_VIS_ONLY param_type
+    class _LIBCPP_TEMPLATE_VIS param_type
     {
         double __p_;
     public:

 // chi_squared_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS_ONLY chi_squared_distribution
+class _LIBCPP_TEMPLATE_VIS chi_squared_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS_ONLY param_type
+    class _LIBCPP_TEMPLATE_VIS param_type
     {
         result_type __n_;
     public:

 // cauchy_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS_ONLY cauchy_distribution
+class _LIBCPP_TEMPLATE_VIS cauchy_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS_ONLY param_type
+    class _LIBCPP_TEMPLATE_VIS param_type
     {
         result_type __a_;
         result_type __b_;

 // fisher_f_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS_ONLY fisher_f_distribution
+class _LIBCPP_TEMPLATE_VIS fisher_f_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS_ONLY param_type
+    class _LIBCPP_TEMPLATE_VIS param_type
     {
         result_type __m_;
         result_type __n_;

 // student_t_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS_ONLY student_t_distribution
+class _LIBCPP_TEMPLATE_VIS student_t_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS_ONLY param_type
+    class _LIBCPP_TEMPLATE_VIS param_type
     {
         result_type __n_;
     public:

 // discrete_distribution
 
 template<class _IntType = int>
-class _LIBCPP_TYPE_VIS_ONLY discrete_distribution
+class _LIBCPP_TEMPLATE_VIS discrete_distribution
 {
 public:
     // types
     typedef _IntType result_type;
 
-    class _LIBCPP_TYPE_VIS_ONLY param_type
+    class _LIBCPP_TEMPLATE_VIS param_type
     {
         vector<double> __p_;
     public:

 // piecewise_constant_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS_ONLY piecewise_constant_distribution
+class _LIBCPP_TEMPLATE_VIS piecewise_constant_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS_ONLY param_type
+    class _LIBCPP_TEMPLATE_VIS param_type
     {
         vector<result_type> __b_;
         vector<result_type> __densities_;

 // piecewise_linear_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS_ONLY piecewise_linear_distribution
+class _LIBCPP_TEMPLATE_VIS piecewise_linear_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS_ONLY param_type
+    class _LIBCPP_TEMPLATE_VIS param_type
     {
         vector<result_type> __b_;
         vector<result_type> __densities_;

include/ratio

 };
 
 template <intmax_t _Num, intmax_t _Den = 1>
-class _LIBCPP_TYPE_VIS_ONLY ratio
+class _LIBCPP_TEMPLATE_VIS ratio
 {
     static_assert(__static_abs<_Num>::value >= 0, "ratio numerator is out of range");
     static_assert(_Den != 0, "ratio divide by 0");

 #else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
 
 template <class _R1, class _R2>
-struct _LIBCPP_TYPE_VIS_ONLY ratio_multiply
+struct _LIBCPP_TEMPLATE_VIS ratio_multiply
     : public __ratio_multiply<_R1, _R2>::type {};
 
 #endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES

 #else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
 
 template <class _R1, class _R2>
-struct _LIBCPP_TYPE_VIS_ONLY ratio_divide
+struct _LIBCPP_TEMPLATE_VIS ratio_divide
     : public __ratio_divide<_R1, _R2>::type {};
 
 #endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES

 #else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
 
 template <class _R1, class _R2>
-struct _LIBCPP_TYPE_VIS_ONLY ratio_add
+struct _LIBCPP_TEMPLATE_VIS ratio_add
     : public __ratio_add<_R1, _R2>::type {};
 
 #endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES

 #else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
 
 template <class _R1, class _R2>
-struct _LIBCPP_TYPE_VIS_ONLY ratio_subtract
+struct _LIBCPP_TEMPLATE_VIS ratio_subtract
     : public __ratio_subtract<_R1, _R2>::type {};
 
 #endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES

 // ratio_equal
 
 template <class _R1, class _R2>
-struct _LIBCPP_TYPE_VIS_ONLY ratio_equal
+struct _LIBCPP_TEMPLATE_VIS ratio_equal
     : public integral_constant<bool, _R1::num == _R2::num && _R1::den == _R2::den> {};
 
 template <class _R1, class _R2>
-struct _LIBCPP_TYPE_VIS_ONLY ratio_not_equal
+struct _LIBCPP_TEMPLATE_VIS ratio_not_equal
     : public integral_constant<bool, !ratio_equal<_R1, _R2>::value> {};
 
 // ratio_less

 };
 
 template <class _R1, class _R2>
-struct _LIBCPP_TYPE_VIS_ONLY ratio_less
+struct _LIBCPP_TEMPLATE_VIS ratio_less
     : public integral_constant<bool, __ratio_less<_R1, _R2>::value> {};
 
 template <class _R1, class _R2>
-struct _LIBCPP_TYPE_VIS_ONLY ratio_less_equal
+struct _LIBCPP_TEMPLATE_VIS ratio_less_equal
     : public integral_constant<bool, !ratio_less<_R2, _R1>::value> {};
 
 template <class _R1, class _R2>
-struct _LIBCPP_TYPE_VIS_ONLY ratio_greater
+struct _LIBCPP_TEMPLATE_VIS ratio_greater
     : public integral_constant<bool, ratio_less<_R2, _R1>::value> {};
 
 template <class _R1, class _R2>
-struct _LIBCPP_TYPE_VIS_ONLY ratio_greater_equal
+struct _LIBCPP_TEMPLATE_VIS ratio_greater_equal
     : public integral_constant<bool, !ratio_less<_R1, _R2>::value> {};
 
 template <class _R1, class _R2>

include/regex

 };
 
 template <class _CharT>
-struct _LIBCPP_TYPE_VIS_ONLY regex_traits
+struct _LIBCPP_TEMPLATE_VIS regex_traits
 {
 public:
     typedef _CharT                  char_type;

 
 template <class _CharT> class __node;
 
-template <class _BidirectionalIterator> class _LIBCPP_TYPE_VIS_ONLY sub_match;
+template <class _BidirectionalIterator> class _LIBCPP_TEMPLATE_VIS sub_match;
 
 template <class _BidirectionalIterator,
           class _Allocator = allocator<sub_match<_BidirectionalIterator> > >
-class _LIBCPP_TYPE_VIS_ONLY match_results;
+class _LIBCPP_TEMPLATE_VIS match_results;
 
 template <class _CharT>
 struct __state

 template <class _CharT, class _Traits> class __lookahead;
 
 template <class _CharT, class _Traits = regex_traits<_CharT> >
-class _LIBCPP_TYPE_VIS_ONLY basic_regex
+class _LIBCPP_TEMPLATE_VIS basic_regex
 {
 public:
     // types:

 // sub_match
 
 template <class _BidirectionalIterator>
-class _LIBCPP_TYPE_VIS_ONLY sub_match
+class _LIBCPP_TEMPLATE_VIS sub_match
     : public pair<_BidirectionalIterator, _BidirectionalIterator>
 {
 public:

 }
 
 template <class _BidirectionalIterator, class _Allocator>
-class _LIBCPP_TYPE_VIS_ONLY match_results
+class _LIBCPP_TEMPLATE_VIS match_results
 {
 public:
     typedef _Allocator                                        allocator_type;

 template <class _BidirectionalIterator,
           class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
           class _Traits = regex_traits<_CharT> >
-class _LIBCPP_TYPE_VIS_ONLY regex_iterator
+class _LIBCPP_TEMPLATE_VIS regex_iterator
 {
 public:
     typedef basic_regex<_CharT, _Traits>          regex_type;

 template <class _BidirectionalIterator,
           class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
           class _Traits = regex_traits<_CharT> >
-class _LIBCPP_TYPE_VIS_ONLY regex_token_iterator
+class _LIBCPP_TEMPLATE_VIS regex_token_iterator
 {
 public:
     typedef basic_regex<_CharT, _Traits>      regex_type;

include/scoped_allocator

 };
 
 template <class _OuterAlloc, class... _InnerAllocs>
-class _LIBCPP_TYPE_VIS_ONLY scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...>
+class _LIBCPP_TEMPLATE_VIS scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...>
     : public __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...>
 {
     typedef __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> base;

include/set

 
 template <class _Key, class _Compare = less<_Key>,
           class _Allocator = allocator<_Key> >
-class _LIBCPP_TYPE_VIS_ONLY set
+class _LIBCPP_TEMPLATE_VIS set
 {
 public:
     // types:

 
 template <class _Key, class _Compare = less<_Key>,
           class _Allocator = allocator<_Key> >
-class _LIBCPP_TYPE_VIS_ONLY multiset
+class _LIBCPP_TEMPLATE_VIS multiset
 {
 public:
     // types:

include/sstream

 // basic_stringbuf
 
 template <class _CharT, class _Traits, class _Allocator>
-class _LIBCPP_TYPE_VIS_ONLY basic_stringbuf
+class _LIBCPP_TEMPLATE_VIS basic_stringbuf
     : public basic_streambuf<_CharT, _Traits>
 {
 public:

 // basic_istringstream
 
 template <class _CharT, class _Traits, class _Allocator>
-class _LIBCPP_TYPE_VIS_ONLY basic_istringstream
+class _LIBCPP_TEMPLATE_VIS basic_istringstream
     : public basic_istream<_CharT, _Traits>
 {
 public:

 // basic_ostringstream
 
 template <class _CharT, class _Traits, class _Allocator>
-class _LIBCPP_TYPE_VIS_ONLY basic_ostringstream
+class _LIBCPP_TEMPLATE_VIS basic_ostringstream
     : public basic_ostream<_CharT, _Traits>
 {
 public:

 // basic_stringstream
 
 template <class _CharT, class _Traits, class _Allocator>
-class _LIBCPP_TYPE_VIS_ONLY basic_stringstream
+class _LIBCPP_TEMPLATE_VIS basic_stringstream
     : public basic_iostream<_CharT, _Traits>
 {
 public:

include/stack

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp, class _Container> class _LIBCPP_TYPE_VIS_ONLY stack;
+template <class _Tp, class _Container> class _LIBCPP_TEMPLATE_VIS stack;
 
 template <class _Tp, class _Container>
 _LIBCPP_INLINE_VISIBILITY

 operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y);
 
 template <class _Tp, class _Container = deque<_Tp> >
-class _LIBCPP_TYPE_VIS_ONLY stack
+class _LIBCPP_TEMPLATE_VIS stack
 {
 public:
     typedef _Container                               container_type;

 }
 
 template <class _Tp, class _Container, class _Alloc>
-struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<stack<_Tp, _Container>, _Alloc>
+struct _LIBCPP_TEMPLATE_VIS uses_allocator<stack<_Tp, _Container>, _Alloc>
     : public uses_allocator<_Container, _Alloc>
 {
 };

include/streambuf

 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS_ONLY basic_streambuf
+class _LIBCPP_TEMPLATE_VIS basic_streambuf
 {
 public:
     // types:

include/string

 // fpos
 
 template <class _StateT>
-class _LIBCPP_TYPE_VIS_ONLY fpos
+class _LIBCPP_TEMPLATE_VIS fpos
 {
 private:
     _StateT __st_;

 // char_traits
 
 template <class _CharT>
-struct _LIBCPP_TYPE_VIS_ONLY char_traits
+struct _LIBCPP_TEMPLATE_VIS char_traits
 {
     typedef _CharT    char_type;
     typedef int       int_type;

 // char_traits<char>
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY char_traits<char>
+struct _LIBCPP_TEMPLATE_VIS char_traits<char>
 {
     typedef char      char_type;
     typedef int       int_type;

 // char_traits<wchar_t>
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY char_traits<wchar_t>
+struct _LIBCPP_TEMPLATE_VIS char_traits<wchar_t>
 {
     typedef wchar_t   char_type;
     typedef wint_t    int_type;

 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY char_traits<char16_t>
+struct _LIBCPP_TEMPLATE_VIS char_traits<char16_t>
 {
     typedef char16_t       char_type;
     typedef uint_least16_t int_type;

 }
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY char_traits<char32_t>
+struct _LIBCPP_TEMPLATE_VIS char_traits<char32_t>
 {
     typedef char32_t       char_type;
     typedef uint_least32_t int_type;

 operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, _CharT __y);
 
 template <bool>
-class _LIBCPP_TYPE_VIS_ONLY __basic_string_common
+class _LIBCPP_TEMPLATE_VIS __basic_string_common
 {
 protected:
     void __throw_length_error() const;

 #endif  // _LIBCPP_ALTERNATE_STRING_LAYOUT
 
 template<class _CharT, class _Traits, class _Allocator>
-class _LIBCPP_TYPE_VIS_ONLY basic_string
+class _LIBCPP_TEMPLATE_VIS basic_string
     : private __basic_string_common<true>
 {
 public:

                    basic_string<_CharT, _Traits, _Allocator>::npos;
 
 template<class _CharT, class _Traits, class _Allocator>
-struct _LIBCPP_TYPE_VIS_ONLY hash<basic_string<_CharT, _Traits, _Allocator> >
+struct _LIBCPP_TEMPLATE_VIS hash<basic_string<_CharT, _Traits, _Allocator> >
     : public unary_function<basic_string<_CharT, _Traits, _Allocator>, size_t>
 {
     size_t

include/system_error

 // is_error_code_enum
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_error_code_enum
+struct _LIBCPP_TEMPLATE_VIS is_error_code_enum
     : public false_type {};
 
 // is_error_condition_enum
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_error_condition_enum
+struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum
     : public false_type {};
 
 // Some error codes are not present on all platforms, so we provide equivalents

 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(errc)
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY is_error_condition_enum<errc>
+struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc>
     : true_type { };
 
 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY is_error_condition_enum<errc::__lx>
+struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc::__lx>
     : true_type { };
 #endif
 

 {return !(__x == __y);}
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY hash<error_code>
+struct _LIBCPP_TEMPLATE_VIS hash<error_code>
     : public unary_function<error_code, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

include/thread

 
 }  // this_thread
 
-template<> struct _LIBCPP_TYPE_VIS_ONLY hash<__thread_id>;
+template<> struct _LIBCPP_TEMPLATE_VIS hash<__thread_id>;
 
-class _LIBCPP_TYPE_VIS_ONLY __thread_id
+class _LIBCPP_TEMPLATE_VIS __thread_id
 {
     // FIXME: pthread_t is a pointer on Darwin but a long on Linux.
     // NULL is the no-thread value on Darwin.  Someone needs to check

 
     friend __thread_id this_thread::get_id() _NOEXCEPT;
     friend class _LIBCPP_TYPE_VIS thread;
-    friend struct _LIBCPP_TYPE_VIS_ONLY hash<__thread_id>;
+    friend struct _LIBCPP_TEMPLATE_VIS hash<__thread_id>;
 };
 
 template<>
-struct _LIBCPP_TYPE_VIS_ONLY hash<__thread_id>
+struct _LIBCPP_TEMPLATE_VIS hash<__thread_id>
     : public unary_function<__thread_id, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

include/tuple

 // tuple_size
 
 template <class ..._Tp>
-class _LIBCPP_TYPE_VIS_ONLY tuple_size<tuple<_Tp...> >
+class _LIBCPP_TEMPLATE_VIS tuple_size<tuple<_Tp...> >
     : public integral_constant<size_t, sizeof...(_Tp)>
 {
 };

 // tuple_element
 
 template <size_t _Ip, class ..._Tp>
-class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, tuple<_Tp...> >
+class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, tuple<_Tp...> >
 {
 public:
     typedef typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;

 };
 
 template <class ..._Tp>
-class _LIBCPP_TYPE_VIS_ONLY tuple
+class _LIBCPP_TEMPLATE_VIS tuple
 {
     typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> base;
 

 };
 
 template <>
-class _LIBCPP_TYPE_VIS_ONLY tuple<>
+class _LIBCPP_TEMPLATE_VIS tuple<>
 {
 public:
     _LIBCPP_INLINE_VISIBILITY

 
 namespace { const __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>(); }
 
-template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY reference_wrapper;
+template <class _Tp> class _LIBCPP_TEMPLATE_VIS reference_wrapper;
 
 template <class _Tp>
 struct __make_tuple_return_impl

 }
 
 template <class ..._Tp, class _Alloc>
-struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<tuple<_Tp...>, _Alloc>
+struct _LIBCPP_TEMPLATE_VIS uses_allocator<tuple<_Tp...>, _Alloc>
     : true_type {};
 
 template <class _T1, class _T2>

include/type_traits

 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <bool _Bp, class _If, class _Then>
-    struct _LIBCPP_TYPE_VIS_ONLY conditional {typedef _If type;};
+    struct _LIBCPP_TEMPLATE_VIS conditional {typedef _If type;};
 template <class _If, class _Then>
-    struct _LIBCPP_TYPE_VIS_ONLY conditional<false, _If, _Then> {typedef _Then type;};
+    struct _LIBCPP_TEMPLATE_VIS conditional<false, _If, _Then> {typedef _Then type;};
 
 #if _LIBCPP_STD_VER > 11
 template <bool _Bp, class _If, class _Then> using conditional_t = typename conditional<_Bp, _If, _Then>::type;
 #endif
 
-template <bool, class _Tp = void> struct _LIBCPP_TYPE_VIS_ONLY enable_if {};
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY enable_if<true, _Tp> {typedef _Tp type;};
+template <bool, class _Tp = void> struct _LIBCPP_TEMPLATE_VIS enable_if {};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS enable_if<true, _Tp> {typedef _Tp type;};
 
 #if _LIBCPP_STD_VER > 11
 template <bool _Bp, class _Tp = void> using enable_if_t = typename enable_if<_Bp, _Tp>::type;

 // helper class:
 
 template <class _Tp, _Tp __v>
-struct _LIBCPP_TYPE_VIS_ONLY integral_constant
+struct _LIBCPP_TEMPLATE_VIS integral_constant
 {
     static _LIBCPP_CONSTEXPR const _Tp      value = __v;
     typedef _Tp               value_type;

 
 // is_const
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_const            : public false_type {};
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_const<_Tp const> : public true_type {};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_const            : public false_type {};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_const<_Tp const> : public true_type {};
 
 // is_volatile
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_volatile               : public false_type {};
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_volatile<_Tp volatile> : public true_type {};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_volatile               : public false_type {};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_volatile<_Tp volatile> : public true_type {};
 
 // remove_const
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_const            {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_const<const _Tp> {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const            {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const<const _Tp> {typedef _Tp type;};
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_const_t = typename remove_const<_Tp>::type;
 #endif
 
 // remove_volatile
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_volatile               {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_volatile<volatile _Tp> {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile               {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile<volatile _Tp> {typedef _Tp type;};
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_volatile_t = typename remove_volatile<_Tp>::type;
 #endif
 
 // remove_cv
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_cv
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_cv
 {typedef typename remove_volatile<typename remove_const<_Tp>::type>::type type;};
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_cv_t = typename remove_cv<_Tp>::type;

 template <class _Tp> struct __libcpp_is_void       : public false_type {};
 template <>          struct __libcpp_is_void<void> : public true_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_void
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_void
     : public __libcpp_is_void<typename remove_cv<_Tp>::type> {};
 
 // __is_nullptr_t

 template <class _Tp> struct __is_nullptr_t_impl       : public false_type {};
 template <>          struct __is_nullptr_t_impl<nullptr_t> : public true_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY __is_nullptr_t
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS __is_nullptr_t
     : public __is_nullptr_t_impl<typename remove_cv<_Tp>::type> {};
 
 #if _LIBCPP_STD_VER > 11
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_null_pointer
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_null_pointer
     : public __is_nullptr_t_impl<typename remove_cv<_Tp>::type> {};
 #endif
 

 template <>          struct __libcpp_is_integral<__uint128_t>        : public true_type {};
 #endif
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_integral
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_integral
     : public __libcpp_is_integral<typename remove_cv<_Tp>::type> {};
 
 // is_floating_point

 template <>          struct __libcpp_is_floating_point<double>      : public true_type {};
 template <>          struct __libcpp_is_floating_point<long double> : public true_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_floating_point
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_floating_point
     : public __libcpp_is_floating_point<typename remove_cv<_Tp>::type> {};
 
 // is_array
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_array
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_array
     : public false_type {};
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_array<_Tp[]>
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_array<_Tp[]>
     : public true_type {};
-template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS_ONLY is_array<_Tp[_Np]>
+template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS is_array<_Tp[_Np]>
     : public true_type {};
 
 // is_pointer

 template <class _Tp> struct __libcpp_is_pointer       : public false_type {};
 template <class _Tp> struct __libcpp_is_pointer<_Tp*> : public true_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_pointer
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pointer
     : public __libcpp_is_pointer<typename remove_cv<_Tp>::type> {};
 
 // is_reference
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_lvalue_reference       : public false_type {};
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_lvalue_reference<_Tp&> : public true_type {};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference       : public false_type {};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference<_Tp&> : public true_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_rvalue_reference        : public false_type {};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference        : public false_type {};
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_rvalue_reference<_Tp&&> : public true_type {};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference<_Tp&&> : public true_type {};
 #endif
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_reference        : public false_type {};
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_reference<_Tp&>  : public true_type {};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference        : public false_type {};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference<_Tp&>  : public true_type {};
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_reference<_Tp&&> : public true_type {};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference<_Tp&&> : public true_type {};
 #endif
 
 // is_union
 
 #if __has_feature(is_union) || (_GNUC_VER >= 403)
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_union
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_union
     : public integral_constant<bool, __is_union(_Tp)> {};
 
 #else
 
 template <class _Tp> struct __libcpp_union : public false_type {};
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_union
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_union
     : public __libcpp_union<typename remove_cv<_Tp>::type> {};
 
 #endif

 
 #if __has_feature(is_class) || (_GNUC_VER >= 403)
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_class
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_class
     : public integral_constant<bool, __is_class(_Tp)> {};
 
 #else

 template <class _Tp> __two __test(...);
 }
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_class
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_class
     : public integral_constant<bool, sizeof(__is_class_imp::__test<_Tp>(0)) == 1 && !is_union<_Tp>::value> {};
 
 #endif
 
 // is_same
 
-template <class _Tp, class _Up> struct _LIBCPP_TYPE_VIS_ONLY is_same           : public false_type {};
-template <class _Tp>            struct _LIBCPP_TYPE_VIS_ONLY is_same<_Tp, _Tp> : public true_type {};
+template <class _Tp, class _Up> struct _LIBCPP_TEMPLATE_VIS is_same           : public false_type {};
+template <class _Tp>            struct _LIBCPP_TEMPLATE_VIS is_same<_Tp, _Tp> : public true_type {};
 
 // is_function
 

     {};
 template <class _Tp> struct __libcpp_is_function<_Tp, true> : public false_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_function
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_function
     : public __libcpp_is_function<_Tp> {};
 
 // is_member_function_pointer

 template <class _Tp> struct __libcpp_is_member_function_pointer
     : public integral_constant<bool, sizeof(__libcpp_is_member_function_pointer_imp::__test<_Tp>(nullptr)) == 1> {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_member_function_pointer
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_function_pointer
     : public __libcpp_is_member_function_pointer<typename remove_cv<_Tp>::type> {};
 
 // is_member_pointer

 template <class _Tp>            struct __libcpp_is_member_pointer             : public false_type {};
 template <class _Tp, class _Up> struct __libcpp_is_member_pointer<_Tp _Up::*> : public true_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_member_pointer
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_pointer
     : public __libcpp_is_member_pointer<typename remove_cv<_Tp>::type> {};
 
 // is_member_object_pointer
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_member_object_pointer
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_object_pointer
     : public integral_constant<bool, is_member_pointer<_Tp>::value &&
                                     !is_member_function_pointer<_Tp>::value> {};
 

 
 #if __has_feature(is_enum) || (_GNUC_VER >= 403)
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_enum
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_enum
     : public integral_constant<bool, __is_enum(_Tp)> {};
 
 #else
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_enum
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_enum
     : public integral_constant<bool, !is_void<_Tp>::value             &&
                                      !is_integral<_Tp>::value         &&
                                      !is_floating_point<_Tp>::value   &&

 
 // is_arithmetic
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_arithmetic
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_arithmetic
     : public integral_constant<bool, is_integral<_Tp>::value      ||
                                      is_floating_point<_Tp>::value> {};
 
 // is_fundamental
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_fundamental
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_fundamental
     : public integral_constant<bool, is_void<_Tp>::value        ||
                                      __is_nullptr_t<_Tp>::value ||
                                      is_arithmetic<_Tp>::value> {};
 
 // is_scalar
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_scalar
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_scalar
     : public integral_constant<bool, is_arithmetic<_Tp>::value     ||
                                      is_member_pointer<_Tp>::value ||
                                      is_pointer<_Tp>::value        ||
                                      __is_nullptr_t<_Tp>::value    ||
                                      is_enum<_Tp>::value           > {};
 
-template <> struct _LIBCPP_TYPE_VIS_ONLY is_scalar<nullptr_t> : public true_type {};
+template <> struct _LIBCPP_TEMPLATE_VIS is_scalar<nullptr_t> : public true_type {};
 
 // is_object
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_object
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_object
     : public integral_constant<bool, is_scalar<_Tp>::value ||
                                      is_array<_Tp>::value  ||
                                      is_union<_Tp>::value  ||

 
 // is_compound
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_compound
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_compound
     : public integral_constant<bool, !is_fundamental<_Tp>::value> {};
 
 // add_const

 template <class _Tp>
 struct __add_const<_Tp, false> {typedef const _Tp type;};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_const
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_const
     {typedef typename __add_const<_Tp>::type type;};
 
 #if _LIBCPP_STD_VER > 11

 template <class _Tp>
 struct __add_volatile<_Tp, false> {typedef volatile _Tp type;};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_volatile
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_volatile
     {typedef typename __add_volatile<_Tp>::type type;};
 
 #if _LIBCPP_STD_VER > 11

 
 // add_cv
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_cv
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_cv
     {typedef typename add_const<typename add_volatile<_Tp>::type>::type type;};
 
 #if _LIBCPP_STD_VER > 11

 
 // remove_reference
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_reference        {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_reference<_Tp&>  {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference        {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&>  {typedef _Tp type;};
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_reference<_Tp&&> {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&&> {typedef _Tp type;};
 #endif
 
 #if _LIBCPP_STD_VER > 11

 
 // add_lvalue_reference
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference                      {typedef _Tp& type;};
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference<_Tp&>                {typedef _Tp& type;};  // for older compiler
-template <>          struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference<void>                {typedef void type;};
-template <>          struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference<const void>          {typedef const void type;};
-template <>          struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference<volatile void>       {typedef volatile void type;};
-template <>          struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference<const volatile void> {typedef const volatile void type;};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_lvalue_reference                      {typedef _Tp& type;};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_lvalue_reference<_Tp&>                {typedef _Tp& type;};  // for older compiler
+template <>          struct _LIBCPP_TEMPLATE_VIS add_lvalue_reference<void>                {typedef void type;};
+template <>          struct _LIBCPP_TEMPLATE_VIS add_lvalue_reference<const void>          {typedef const void type;};
+template <>          struct _LIBCPP_TEMPLATE_VIS add_lvalue_reference<volatile void>       {typedef volatile void type;};
+template <>          struct _LIBCPP_TEMPLATE_VIS add_lvalue_reference<const volatile void> {typedef const volatile void type;};
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;

 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY  add_rvalue_reference                     {typedef _Tp&& type;};
-template <>          struct _LIBCPP_TYPE_VIS_ONLY add_rvalue_reference<void>                {typedef void type;};
-template <>          struct _LIBCPP_TYPE_VIS_ONLY add_rvalue_reference<const void>          {typedef const void type;};
-template <>          struct _LIBCPP_TYPE_VIS_ONLY add_rvalue_reference<volatile void>       {typedef volatile void type;};
-template <>          struct _LIBCPP_TYPE_VIS_ONLY add_rvalue_reference<const volatile void> {typedef const volatile void type;};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS  add_rvalue_reference                     {typedef _Tp&& type;};
+template <>          struct _LIBCPP_TEMPLATE_VIS add_rvalue_reference<void>                {typedef void type;};
+template <>          struct _LIBCPP_TEMPLATE_VIS add_rvalue_reference<const void>          {typedef const void type;};
+template <>          struct _LIBCPP_TEMPLATE_VIS add_rvalue_reference<volatile void>       {typedef volatile void type;};
+template <>          struct _LIBCPP_TEMPLATE_VIS add_rvalue_reference<const volatile void> {typedef const volatile void type;};
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;

 
 // remove_pointer
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_pointer                      {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_pointer<_Tp*>                {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_pointer<_Tp* const>          {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_pointer<_Tp* volatile>       {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_pointer<_Tp* const volatile> {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer                      {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp*>                {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const>          {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* volatile>       {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const volatile> {typedef _Tp type;};
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_pointer_t = typename remove_pointer<_Tp>::type;

 
 // add_pointer
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_pointer
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_pointer
     {typedef typename remove_reference<_Tp>::type* type;};
 
 #if _LIBCPP_STD_VER > 11

 
 template <class _Tp> struct __libcpp_is_signed<_Tp, false> : public false_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_signed : public __libcpp_is_signed<_Tp> {};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_signed : public __libcpp_is_signed<_Tp> {};
 
 // is_unsigned
 

 
 template <class _Tp> struct __libcpp_is_unsigned<_Tp, false> : public false_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_unsigned : public __libcpp_is_unsigned<_Tp> {};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_unsigned : public __libcpp_is_unsigned<_Tp> {};
 
 // rank
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY rank
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS rank
     : public integral_constant<size_t, 0> {};
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY rank<_Tp[]>
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS rank<_Tp[]>
     : public integral_constant<size_t, rank<_Tp>::value + 1> {};
-template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS_ONLY rank<_Tp[_Np]>
+template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS rank<_Tp[_Np]>
     : public integral_constant<size_t, rank<_Tp>::value + 1> {};
 
 // extent
 
-template <class _Tp, unsigned _Ip = 0> struct _LIBCPP_TYPE_VIS_ONLY extent
+template <class _Tp, unsigned _Ip = 0> struct _LIBCPP_TEMPLATE_VIS extent
     : public integral_constant<size_t, 0> {};
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY extent<_Tp[], 0>
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[], 0>
     : public integral_constant<size_t, 0> {};
-template <class _Tp, unsigned _Ip> struct _LIBCPP_TYPE_VIS_ONLY extent<_Tp[], _Ip>
+template <class _Tp, unsigned _Ip> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[], _Ip>
     : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
-template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS_ONLY extent<_Tp[_Np], 0>
+template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[_Np], 0>
     : public integral_constant<size_t, _Np> {};
-template <class _Tp, size_t _Np, unsigned _Ip> struct _LIBCPP_TYPE_VIS_ONLY extent<_Tp[_Np], _Ip>
+template <class _Tp, size_t _Np, unsigned _Ip> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[_Np], _Ip>
     : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
 
 // remove_extent
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_extent
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_extent
     {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_extent<_Tp[]>
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_extent<_Tp[]>
     {typedef _Tp type;};
-template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS_ONLY remove_extent<_Tp[_Np]>
+template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS remove_extent<_Tp[_Np]>
     {typedef _Tp type;};
 
 #if _LIBCPP_STD_VER > 11

 
 // remove_all_extents
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_all_extents
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_all_extents
     {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_all_extents<_Tp[]>
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_all_extents<_Tp[]>
     {typedef typename remove_all_extents<_Tp>::type type;};
-template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS_ONLY remove_all_extents<_Tp[_Np]>
+template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS remove_all_extents<_Tp[_Np]>
     {typedef typename remove_all_extents<_Tp>::type type;};
 
 #if _LIBCPP_STD_VER > 11

 // decay
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY decay
+struct _LIBCPP_TEMPLATE_VIS decay
 {
 private:
     typedef typename remove_reference<_Tp>::type _Up;

 
 template <class _Tp> struct __libcpp_abstract<_Tp, false> : public false_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_abstract : public __libcpp_abstract<_Tp> {};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_abstract : public __libcpp_abstract<_Tp> {};
 
 // is_final
 
 #if _LIBCPP_STD_VER > 11 && __has_feature(is_final)
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY 
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS 
 is_final : public integral_constant<bool, __is_final(_Tp)> {};
 #endif
 

 #ifdef _LIBCPP_HAS_IS_BASE_OF
 
 template <class _Bp, class _Dp>
-struct _LIBCPP_TYPE_VIS_ONLY is_base_of
+struct _LIBCPP_TEMPLATE_VIS is_base_of
     : public integral_constant<bool, __is_base_of(_Bp, _Dp)> {};
 
 #else  // _LIBCPP_HAS_IS_BASE_OF

 }
 
 template <class _Bp, class _Dp>
-struct _LIBCPP_TYPE_VIS_ONLY is_base_of
+struct _LIBCPP_TEMPLATE_VIS is_base_of
     : public integral_constant<bool, is_class<_Bp>::value &&
                                      sizeof(__is_base_of_imp::__test<_Bp, _Dp>(0)) == 2> {};
 

 
 #if __has_feature(is_convertible_to)
 
-template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS_ONLY is_convertible
+template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS is_convertible
     : public integral_constant<bool, __is_convertible_to(_T1, _T2) &&
                                      !is_abstract<_T2>::value> {};
 

 template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 3> : public false_type {};
 template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 3> : public true_type {};
 
-template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS_ONLY is_convertible
+template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS is_convertible
     : public __is_convertible<_T1, _T2>
 {
     static const size_t __complete_check1 = __is_convertible_check<_T1>::__v;

 #if __has_feature(is_empty) || (_GNUC_VER >= 407)
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_empty
+struct _LIBCPP_TEMPLATE_VIS is_empty
     : public integral_constant<bool, __is_empty(_Tp)> {};
 
 #else  // __has_feature(is_empty)

 
 template <class _Tp> struct __libcpp_empty<_Tp, false> : public false_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_empty : public __libcpp_empty<_Tp> {};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_empty : public __libcpp_empty<_Tp> {};
 
 #endif  // __has_feature(is_empty)
 

 #if __has_feature(is_polymorphic) || defined(_LIBCPP_MSVC)
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_polymorphic
+struct _LIBCPP_TEMPLATE_VIS is_polymorphic
     : public integral_constant<bool, __is_polymorphic(_Tp)> {};
 
 #else

                        int>::type);
 template<typename _Tp> __two &__is_polymorphic_impl(...);
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_polymorphic
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_polymorphic
     : public integral_constant<bool, sizeof(__is_polymorphic_impl<_Tp>(0)) == 1> {};
 
 #endif // __has_feature(is_polymorphic)

 
 #if __has_feature(has_virtual_destructor) || (_GNUC_VER >= 403)
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY has_virtual_destructor
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS has_virtual_destructor
     : public integral_constant<bool, __has_virtual_destructor(_Tp)> {};
 
 #else
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY has_virtual_destructor
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS has_virtual_destructor
     : public false_type {};
 
 #endif
 
 // alignment_of
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY alignment_of
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS alignment_of
     : public integral_constant<size_t, __alignof__(_Tp)> {};
 
 // aligned_storage

     : public integral_constant<size_t, __select_align<_Len, _Hp::value, __find_max_align<_Tp, _Len>::value>::value> {};
 
 template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
-struct _LIBCPP_TYPE_VIS_ONLY aligned_storage
+struct _LIBCPP_TEMPLATE_VIS aligned_storage
 {
     typedef typename __find_pod<__all_types, _Align>::type _Aligner;
     static_assert(!is_void<_Aligner>::value, "");

 
 #define _CREATE_ALIGNED_STORAGE_SPECIALIZATION(n) \
 template <size_t _Len>\
-struct _LIBCPP_TYPE_VIS_ONLY aligned_storage<_Len, n>\
+struct _LIBCPP_TEMPLATE_VIS aligned_storage<_Len, n>\
 {\
     struct _ALIGNAS(n) type\
     {\

 #endif
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY make_signed
+struct _LIBCPP_TEMPLATE_VIS make_signed
 {
     typedef typename __apply_cv<_Tp, typename __make_signed<typename remove_cv<_Tp>::type>::type>::type type;
 };

 #endif
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY make_unsigned
+struct _LIBCPP_TEMPLATE_VIS make_unsigned
 {
     typedef typename __apply_cv<_Tp, typename __make_unsigned<typename remove_cv<_Tp>::type>::type>::type type;
 };

 #ifdef _LIBCPP_HAS_NO_VARIADICS
 
 template <class _Tp, class _Up = void, class V = void>
-struct _LIBCPP_TYPE_VIS_ONLY common_type
+struct _LIBCPP_TEMPLATE_VIS common_type
 {
 public:
     typedef typename common_type<typename common_type<_Tp, _Up>::type, V>::type type;
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY common_type<_Tp, void, void>
+struct _LIBCPP_TEMPLATE_VIS common_type<_Tp, void, void>
 {
 public:
     typedef typename decay<_Tp>::type type;
 };
 
 template <class _Tp, class _Up>
-struct _LIBCPP_TYPE_VIS_ONLY common_type<_Tp, _Up, void>
+struct _LIBCPP_TEMPLATE_VIS common_type<_Tp, _Up, void>
 {
 private:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

 template <class ..._Tp> struct common_type;
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY common_type<_Tp>
+struct _LIBCPP_TEMPLATE_VIS common_type<_Tp>
 {
     typedef typename decay<_Tp>::type type;
 };
 
 template <class _Tp, class _Up>
-struct _LIBCPP_TYPE_VIS_ONLY common_type<_Tp, _Up>
+struct _LIBCPP_TEMPLATE_VIS common_type<_Tp, _Up>
 {
 private:
     static _Tp&& __t();

 };
 
 template <class _Tp, class _Up, class ..._Vp>
-struct _LIBCPP_TYPE_VIS_ONLY common_type<_Tp, _Up, _Vp...>
+struct _LIBCPP_TEMPLATE_VIS common_type<_Tp, _Up, _Vp...>
 {
     typedef typename common_type<typename common_type<_Tp, _Up>::type, _Vp...>::type type;
 };

 
 // is_copy_assignable
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_copy_assignable
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_copy_assignable
     : public is_assignable<typename add_lvalue_reference<_Tp>::type,
                      const typename add_lvalue_reference<_Tp>::type> {};
 
 // is_move_assignable
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_move_assignable
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_move_assignable
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     : public is_assignable<typename add_lvalue_reference<_Tp>::type,
                      const typename add_rvalue_reference<_Tp>::type> {};

 // result_of
 
 template <class _Fn>
-class _LIBCPP_TYPE_VIS_ONLY result_of<_Fn()>
+class _LIBCPP_TEMPLATE_VIS result_of<_Fn()>
     : public __result_of<_Fn(),
                          is_class<typename remove_reference<_Fn>::type>::value ||
                          is_function<typename remove_reference<_Fn>::type>::value,

 };
 
 template <class _Fn, class _A0>
-class _LIBCPP_TYPE_VIS_ONLY result_of<_Fn(_A0)>
+class _LIBCPP_TEMPLATE_VIS result_of<_Fn(_A0)>
     : public __result_of<_Fn(_A0),
                          is_class<typename remove_reference<_Fn>::type>::value ||
                          is_function<typename remove_reference<_Fn>::type>::value,

 };
 
 template <class _Fn, class _A0, class _A1>
-class _LIBCPP_TYPE_VIS_ONLY result_of<_Fn(_A0, _A1)>
+class _LIBCPP_TEMPLATE_VIS result_of<_Fn(_A0, _A1)>
     : public __result_of<_Fn(_A0, _A1),
                          is_class<typename remove_reference<_Fn>::type>::value ||
                          is_function<typename remove_reference<_Fn>::type>::value,

 };
 
 template <class _Fn, class _A0, class _A1, class _A2>
-class _LIBCPP_TYPE_VIS_ONLY result_of<_Fn(_A0, _A1, _A2)>
+class _LIBCPP_TEMPLATE_VIS result_of<_Fn(_A0, _A1, _A2)>
     : public __result_of<_Fn(_A0, _A1, _A2),
                          is_class<typename remove_reference<_Fn>::type>::value ||
                          is_function<typename remove_reference<_Fn>::type>::value,

 #if __has_feature(is_constructible)
 
 template <class _Tp, class ..._Args>
-struct _LIBCPP_TYPE_VIS_ONLY is_constructible
+struct _LIBCPP_TEMPLATE_VIS is_constructible
     : public integral_constant<bool, __is_constructible(_Tp, _Args...)>
     {};
 

 //      is_constructible entry point
 
 template <class _Tp, class... _Args>
-struct _LIBCPP_TYPE_VIS_ONLY is_constructible
+struct _LIBCPP_TEMPLATE_VIS is_constructible
     : public __is_constructible_void_check<__contains_void<_Tp, _Args...>::value
                                         || is_abstract<_Tp>::value,
                                            _Tp, _Args...>

 
 template <class _Tp, class _A0 = __is_construct::__nat,
                      class _A1 = __is_construct::__nat>
-struct _LIBCPP_TYPE_VIS_ONLY is_constructible
+struct _LIBCPP_TEMPLATE_VIS is_constructible
     : public __is_constructible2_void_check<is_void<_Tp>::value
                                         || is_abstract<_Tp>::value
                                         || is_function<_Tp>::value

     {};
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_constructible<_Tp, __is_construct::__nat, __is_construct::__nat>
+struct _LIBCPP_TEMPLATE_VIS is_constructible<_Tp, __is_construct::__nat, __is_construct::__nat>
     : public __is_constructible0_void_check<is_void<_Tp>::value
                                         || is_abstract<_Tp>::value
                                         || is_function<_Tp>::value,

     {};
 
 template <class _Tp, class _A0>
-struct _LIBCPP_TYPE_VIS_ONLY is_constructible<_Tp, _A0, __is_construct::__nat>
+struct _LIBCPP_TEMPLATE_VIS is_constructible<_Tp, _A0, __is_construct::__nat>
     : public __is_constructible1_void_check<is_void<_Tp>::value
                                         || is_abstract<_Tp>::value
                                         || is_function<_Tp>::value

 // is_default_constructible
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_default_constructible
+struct _LIBCPP_TEMPLATE_VIS is_default_constructible
     : public is_constructible<_Tp>
     {};
 
 // is_copy_constructible
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_copy_constructible
+struct _LIBCPP_TEMPLATE_VIS is_copy_constructible
     : public is_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type>
     {};
 
 // is_move_constructible
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_move_constructible
+struct _LIBCPP_TEMPLATE_VIS is_move_constructible
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     : public is_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
 #else

 #if __has_feature(is_trivially_constructible)
 
 template <class _Tp, class... _Args>
-struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible
+struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible
     : integral_constant<bool, __is_trivially_constructible(_Tp, _Args...)>
 {
 };

 #else  // !__has_feature(is_trivially_constructible)
 
 template <class _Tp, class... _Args>
-struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible
+struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible
     : false_type
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp>
+struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp>
 #if __has_feature(has_trivial_constructor) || (_GNUC_VER >= 403)
     : integral_constant<bool, __has_trivial_constructor(_Tp)>
 #else

 
 template <class _Tp>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp&&>
+struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, _Tp&&>
 #else
-struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, _Tp>
 #endif
     : integral_constant<bool, is_scalar<_Tp>::value>
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, const _Tp&>
+struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, const _Tp&>
     : integral_constant<bool, is_scalar<_Tp>::value>
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp&>
+struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, _Tp&>
     : integral_constant<bool, is_scalar<_Tp>::value>
 {
 };

 
 template <class _Tp, class _A0 = __is_construct::__nat,
                      class _A1 = __is_construct::__nat>
-struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible
+struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible
     : false_type
 {
 };

 #if __has_feature(is_trivially_constructible)
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, __is_construct::__nat,
+struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, __is_construct::__nat,
                                                        __is_construct::__nat>
     : integral_constant<bool, __is_trivially_constructible(_Tp)>
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp,
+struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, _Tp,
                                                        __is_construct::__nat>
     : integral_constant<bool, __is_trivially_constructible(_Tp, _Tp)>
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, const _Tp&,
+struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, const _Tp&,
                                                        __is_construct::__nat>
     : integral_constant<bool, __is_trivially_constructible(_Tp, const _Tp&)>
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp&,
+struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, _Tp&,
                                                        __is_construct::__nat>
     : integral_constant<bool, __is_trivially_constructible(_Tp, _Tp&)>
 {

 #else  // !__has_feature(is_trivially_constructible)
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, __is_construct::__nat,
+struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, __is_construct::__nat,
                                                        __is_construct::__nat>
     : integral_constant<bool, is_scalar<_Tp>::value>
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp,
+struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, _Tp,
                                                        __is_construct::__nat>
     : integral_constant<bool, is_scalar<_Tp>::value>
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, const _Tp&,
+struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, const _Tp&,
                                                        __is_construct::__nat>
     : integral_constant<bool, is_scalar<_Tp>::value>
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp&,
+struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, _Tp&,
                                                        __is_construct::__nat>
     : integral_constant<bool, is_scalar<_Tp>::value>
 {

 
 // is_trivially_default_constructible
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_default_constructible
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_default_constructible
     : public is_trivially_constructible<_Tp>
     {};
 
 // is_trivially_copy_constructible
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_copy_constructible
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_constructible
     : public is_trivially_constructible<_Tp, typename add_lvalue_reference<const _Tp>::type>
     {};
 
 // is_trivially_move_constructible
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_move_constructible
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_move_constructible
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     : public is_trivially_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
 #else

 
 // is_trivially_copy_assignable
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_copy_assignable
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_assignable
     : public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type,
                                const typename add_lvalue_reference<_Tp>::type>
     {};
 
 // is_trivially_move_assignable
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_move_assignable
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_move_assignable
     : public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type,
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
                                      typename add_rvalue_reference<_Tp>::type>

 
 #if __has_feature(has_trivial_destructor) || (_GNUC_VER >= 403)
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_destructible
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_destructible
     : public integral_constant<bool, __has_trivial_destructor(_Tp)> {};
 
 #else

     : public integral_constant<bool, is_scalar<_Tp>::value ||
                                      is_reference<_Tp>::value> {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_destructible
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_destructible
     : public __libcpp_trivial_destructor<typename remove_all_extents<_Tp>::type> {};
 
 #endif

 
 #if 0
 template <class _Tp, class... _Args>
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible
     : public integral_constant<bool, __is_nothrow_constructible(_Tp(_Args...))>
 {
 };

 };
 
 template <class _Tp, class... _Args>
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible
     : __libcpp_is_nothrow_constructible<is_constructible<_Tp, _Args...>::value, _Tp, _Args...>
 {
 };
 
 template <class _Tp, size_t _Ns>
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp[_Ns]>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp[_Ns]>
     : __libcpp_is_nothrow_constructible<is_constructible<_Tp>::value, _Tp>
 {
 };

 #else  // __has_feature(cxx_noexcept)
 
 template <class _Tp, class... _Args>
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible
     : false_type
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp>
 #if __has_feature(has_nothrow_constructor) || (_GNUC_VER >= 403)
     : integral_constant<bool, __has_nothrow_constructor(_Tp)>
 #else

 
 template <class _Tp>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, _Tp&&>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp, _Tp&&>
 #else
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp, _Tp>
 #endif
 #if __has_feature(has_nothrow_copy) || (_GNUC_VER >= 403)
     : integral_constant<bool, __has_nothrow_copy(_Tp)>

 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, const _Tp&>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp, const _Tp&>
 #if __has_feature(has_nothrow_copy) || (_GNUC_VER >= 403)
     : integral_constant<bool, __has_nothrow_copy(_Tp)>
 #else

 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, _Tp&>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp, _Tp&>
 #if __has_feature(has_nothrow_copy) || (_GNUC_VER >= 403)
     : integral_constant<bool, __has_nothrow_copy(_Tp)>
 #else

 
 template <class _Tp, class _A0 = __is_construct::__nat,
                      class _A1 = __is_construct::__nat>
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible
     : false_type
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, __is_construct::__nat,
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp, __is_construct::__nat,
                                                        __is_construct::__nat>
 #if __has_feature(has_nothrow_constructor) || (_GNUC_VER >= 403)
     : integral_constant<bool, __has_nothrow_constructor(_Tp)>

 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, _Tp,
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp, _Tp,
                                                        __is_construct::__nat>
 #if __has_feature(has_nothrow_copy) || (_GNUC_VER >= 403)
     : integral_constant<bool, __has_nothrow_copy(_Tp)>

 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, const _Tp&,
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp, const _Tp&,
                                                        __is_construct::__nat>
 #if __has_feature(has_nothrow_copy) || (_GNUC_VER >= 403)
     : integral_constant<bool, __has_nothrow_copy(_Tp)>

 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, _Tp&,
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp, _Tp&,
                                                        __is_construct::__nat>
 #if __has_feature(has_nothrow_copy) || (_GNUC_VER >= 403)
     : integral_constant<bool, __has_nothrow_copy(_Tp)>

 
 // is_nothrow_default_constructible
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_default_constructible
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_default_constructible
     : public is_nothrow_constructible<_Tp>
     {};
 
 // is_nothrow_copy_constructible
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_copy_constructible
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_constructible
     : public is_nothrow_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type>
     {};
 
 // is_nothrow_move_constructible
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_move_constructible
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_constructible
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     : public is_nothrow_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
 #else

 };
 
 template <class _Tp, class _Arg>
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_assignable
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_assignable
     : public __libcpp_is_nothrow_assignable<is_assignable<_Tp, _Arg>::value, _Tp, _Arg>
 {
 };

 #else  // __has_feature(cxx_noexcept)
 
 template <class _Tp, class _Arg>
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_assignable
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_assignable
     : public false_type {};
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_assignable<_Tp&, _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_assignable<_Tp&, _Tp>
 #if __has_feature(has_nothrow_assign) || (_GNUC_VER >= 403)
     : integral_constant<bool, __has_nothrow_assign(_Tp)> {};
 #else

 #endif
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_assignable<_Tp&, _Tp&>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_assignable<_Tp&, _Tp&>
 #if __has_feature(has_nothrow_assign) || (_GNUC_VER >= 403)
     : integral_constant<bool, __has_nothrow_assign(_Tp)> {};
 #else

 #endif
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_assignable<_Tp&, const _Tp&>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_assignable<_Tp&, const _Tp&>
 #if __has_feature(has_nothrow_assign) || (_GNUC_VER >= 403)
     : integral_constant<bool, __has_nothrow_assign(_Tp)> {};
 #else

 
 // is_nothrow_copy_assignable
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_copy_assignable
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_assignable
     : public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type,
                                const typename add_lvalue_reference<_Tp>::type>
     {};
 
 // is_nothrow_move_assignable
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_move_assignable
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_assignable
     : public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type,
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
                                      typename add_rvalue_reference<_Tp>::type>

 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_destructible
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible
     : public __libcpp_is_nothrow_destructible<is_destructible<_Tp>::value, _Tp>
 {
 };
 
 template <class _Tp, size_t _Ns>
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_destructible<_Tp[_Ns]>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp[_Ns]>
     : public is_nothrow_destructible<_Tp>
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_destructible<_Tp&>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp&>
     : public true_type
 {
 };

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_destructible<_Tp&&>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp&&>
     : public true_type
 {
 };

     : public integral_constant<bool, is_scalar<_Tp>::value ||
                                      is_reference<_Tp>::value> {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_destructible
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible
     : public __libcpp_nothrow_destructor<typename remove_all_extents<_Tp>::type> {};
 
 #endif

 
 #if __has_feature(is_pod) || (_GNUC_VER >= 403)
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_pod
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pod
     : public integral_constant<bool, __is_pod(_Tp)> {};
 
 #else
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_pod
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pod
     : public integral_constant<bool, is_trivially_default_constructible<_Tp>::value   &&
                                      is_trivially_copy_constructible<_Tp>::value      &&
                                      is_trivially_copy_assignable<_Tp>::value    &&

 
 // is_literal_type;
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_literal_type
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_literal_type
 #ifdef _LIBCPP_IS_LITERAL
     : public integral_constant<bool, _LIBCPP_IS_LITERAL(_Tp)>
 #else

     
 // is_standard_layout;
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_standard_layout
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_standard_layout
 #if __has_feature(is_standard_layout) || (_GNUC_VER >= 407)
     : public integral_constant<bool, __is_standard_layout(_Tp)>
 #else

     
 // is_trivially_copyable;
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_copyable
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_copyable
 #if __has_feature(is_trivially_copyable)
     : public integral_constant<bool, __is_trivially_copyable(_Tp)>
 #else

     
 // is_trivial;
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivial
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivial
 #if __has_feature(is_trivial) || (_GNUC_VER >= 407)
     : public integral_constant<bool, __is_trivial(_Tp)>
 #else

 };
 
 template <class _Fp, class ..._Args>
-class _LIBCPP_TYPE_VIS_ONLY result_of<_Fp(_Args...)>
+class _LIBCPP_TEMPLATE_VIS result_of<_Fp(_Args...)>
     : public __invoke_of<_Fp, _Args...>
 {
 };

include/typeindex

     const char* name() const _NOEXCEPT {return __t_->name();}
 };
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY hash;
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS hash;
 
 template <>
-struct _LIBCPP_TYPE_VIS_ONLY hash<type_index>
+struct _LIBCPP_TEMPLATE_VIS hash<type_index>
     : public unary_function<type_index, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY

include/unordered_map

 #endif
 
 template <class _HashIterator>
-class _LIBCPP_TYPE_VIS_ONLY __hash_map_iterator
+class _LIBCPP_TEMPLATE_VIS __hash_map_iterator
 {
     _HashIterator __i_;
 

         bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
         {return __x.__i_ != __y.__i_;}
 
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_multimap;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_iterator;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_local_iterator;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_map_const_iterator;
+    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
+    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
 };
 
 template <class _HashIterator>
-class _LIBCPP_TYPE_VIS_ONLY __hash_map_const_iterator
+class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator
 {
     _HashIterator __i_;
 

         bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
         {return __x.__i_ != __y.__i_;}
 
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_multimap;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_iterator;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_local_iterator;
+    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
+    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
 };
 
 template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
           class _Alloc = allocator<pair<const _Key, _Tp> > >
-class _LIBCPP_TYPE_VIS_ONLY unordered_map
+class _LIBCPP_TEMPLATE_VIS unordered_map
 {
 public:
     // types

 
 template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
           class _Alloc = allocator<pair<const _Key, _Tp> > >
-class _LIBCPP_TYPE_VIS_ONLY unordered_multimap
+class _LIBCPP_TEMPLATE_VIS unordered_multimap
 {
 public:
     // types

include/unordered_set

 
 template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
           class _Alloc = allocator<_Value> >
-class _LIBCPP_TYPE_VIS_ONLY unordered_set
+class _LIBCPP_TEMPLATE_VIS unordered_set
 {
 public:
     // types

 
 template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
           class _Alloc = allocator<_Value> >
-class _LIBCPP_TYPE_VIS_ONLY unordered_multiset
+class _LIBCPP_TEMPLATE_VIS unordered_multiset
 {
 public:
     // types

include/utility

 #endif
 
 template <class _T1, class _T2>
-struct _LIBCPP_TYPE_VIS_ONLY pair
+struct _LIBCPP_TEMPLATE_VIS pair
 {
     typedef _T1 first_type;
     typedef _T2 second_type;

 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY reference_wrapper;
+template <class _Tp> class _LIBCPP_TEMPLATE_VIS reference_wrapper;
 
 template <class _Tp>
 struct __make_pair_return_impl

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _T1, class _T2>
-  class _LIBCPP_TYPE_VIS_ONLY tuple_size<pair<_T1, _T2> >
+  class _LIBCPP_TEMPLATE_VIS tuple_size<pair<_T1, _T2> >
     : public integral_constant<size_t, 2> {};
 
 template <class _T1, class _T2>
-  class _LIBCPP_TYPE_VIS_ONLY tuple_size<const pair<_T1, _T2> >
+  class _LIBCPP_TEMPLATE_VIS tuple_size<const pair<_T1, _T2> >
     : public integral_constant<size_t, 2> {};
 
 template <class _T1, class _T2>
-class _LIBCPP_TYPE_VIS_ONLY tuple_element<0, pair<_T1, _T2> >
+class _LIBCPP_TEMPLATE_VIS tuple_element<0, pair<_T1, _T2> >
 {
 public:
     typedef _T1 type;
 };
 
 template <class _T1, class _T2>
-class _LIBCPP_TYPE_VIS_ONLY tuple_element<1, pair<_T1, _T2> >
+class _LIBCPP_TEMPLATE_VIS tuple_element<1, pair<_T1, _T2> >
 {
 public:
     typedef _T2 type;
 };
 
 template <class _T1, class _T2>
-class _LIBCPP_TYPE_VIS_ONLY tuple_element<0, const pair<_T1, _T2> >
+class _LIBCPP_TEMPLATE_VIS tuple_element<0, const pair<_T1, _T2> >
 {
 public:
     typedef const _T1 type;
 };
 
 template <class _T1, class _T2>
-class _LIBCPP_TYPE_VIS_ONLY tuple_element<1, const pair<_T1, _T2> >
+class _LIBCPP_TEMPLATE_VIS tuple_element<1, const pair<_T1, _T2> >
 {
 public:
     typedef const _T2 type;

 #if _LIBCPP_STD_VER > 11
 
 template<class _Tp, _Tp... _Ip>
-struct _LIBCPP_TYPE_VIS_ONLY integer_sequence
+struct _LIBCPP_TEMPLATE_VIS integer_sequence
 {
     typedef _Tp value_type;
     static_assert( is_integral<_Tp>::value,

include/valarray

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _Tp> class _LIBCPP_TYPE_VIS_ONLY valarray;
+template<class _Tp> class _LIBCPP_TEMPLATE_VIS valarray;
 
-class _LIBCPP_TYPE_VIS_ONLY slice
+class _LIBCPP_TEMPLATE_VIS slice
 {
     size_t __start_;
     size_t __size_;

     _LIBCPP_INLINE_VISIBILITY size_t stride() const {return __stride_;}
 };
 
-template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY slice_array;
+template <class _Tp> class _LIBCPP_TEMPLATE_VIS slice_array;
 class _LIBCPP_TYPE_VIS gslice;
-template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY gslice_array;
-template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY mask_array;
-template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY indirect_array;
+template <class _Tp> class _LIBCPP_TEMPLATE_VIS gslice_array;
+template <class _Tp> class _LIBCPP_TEMPLATE_VIS mask_array;
+template <class _Tp> class _LIBCPP_TEMPLATE_VIS indirect_array;
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY

     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __size_;}
 
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY valarray;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS valarray;
 };
 
 template <class _ValExpr>

 struct __is_val_expr<valarray<_Tp> > : true_type {};
 
 template<class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY valarray
+class _LIBCPP_TEMPLATE_VIS valarray
 {
 public:
     typedef _Tp value_type;

     void     resize(size_t __n, value_type __x = value_type());
 
 private:
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY valarray;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY slice_array;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY gslice_array;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY mask_array;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS valarray;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS slice_array;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS gslice_array;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS mask_array;
     template <class> friend class __mask_expr;
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY indirect_array;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS indirect_array;
     template <class> friend class __indirect_expr;
     template <class> friend class __val_expr;
 

 // slice_array
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY slice_array
+class _LIBCPP_TEMPLATE_VIS slice_array
 {
 public:
     typedef _Tp value_type;

 // gslice_array
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY gslice_array
+class _LIBCPP_TEMPLATE_VIS gslice_array
 {
 public:
     typedef _Tp value_type;

 // mask_array
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY mask_array
+class _LIBCPP_TEMPLATE_VIS mask_array
 {
 public:
     typedef _Tp value_type;

 // indirect_array
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS_ONLY indirect_array
+class _LIBCPP_TEMPLATE_VIS indirect_array
 {
 public:
     typedef _Tp value_type;

     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __1d_.size();}
 
-    template <class> friend class _LIBCPP_TYPE_VIS_ONLY valarray;
+    template <class> friend class _LIBCPP_TEMPLATE_VIS valarray;
 };
 
 template<class _ValExpr>

include/vector

 }
 
 template <class _Tp, class _Allocator = allocator<_Tp> >
-class _LIBCPP_TYPE_VIS_ONLY vector
+class _LIBCPP_TEMPLATE_VIS vector
     : private __vector_base<_Tp, _Allocator>
 {
 private:

 };
 
 template <class _Allocator>
-class _LIBCPP_TYPE_VIS_ONLY vector<bool, _Allocator>
+class _LIBCPP_TEMPLATE_VIS vector<bool, _Allocator>
     : private __vector_base_common<true>
 {
 public:

     friend class __bit_iterator<vector, false>;
     friend class __bit_iterator<vector, true>;
     friend struct __bit_array<vector>;
-    friend struct _LIBCPP_TYPE_VIS_ONLY hash<vector>;
+    friend struct _LIBCPP_TEMPLATE_VIS hash<vector>;
 };
 
 template <class _Allocator>

 }
 
 template <class _Allocator>
-struct _LIBCPP_TYPE_VIS_ONLY hash<vector<bool, _Allocator> >
+struct _LIBCPP_TEMPLATE_VIS hash<vector<bool, _Allocator> >
     : public unary_function<vector<bool, _Allocator>, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY