diff --git a/libcxx/include/numbers b/libcxx/include/numbers
--- a/libcxx/include/numbers
+++ b/libcxx/include/numbers
@@ -73,42 +73,42 @@
 
 namespace numbers {
 
-template <class T>
+template <class _Tp>
 inline constexpr bool __false = false;
 
-template <class T>
+template <class _Tp>
 struct __illformed
 {
-  static_assert(__false<T>, "A program that instantiates a primary template of a mathematical constant variable template is ill-formed.");
+  static_assert(__false<_Tp>, "A program that instantiates a primary template of a mathematical constant variable template is ill-formed.");
 };
 
-template <class T> inline constexpr T e_v =          __illformed<T>{};
-template <class T> inline constexpr T log2e_v =      __illformed<T>{};
-template <class T> inline constexpr T log10e_v =     __illformed<T>{};
-template <class T> inline constexpr T pi_v =         __illformed<T>{};
-template <class T> inline constexpr T inv_pi_v =     __illformed<T>{};
-template <class T> inline constexpr T inv_sqrtpi_v = __illformed<T>{};
-template <class T> inline constexpr T ln2_v =        __illformed<T>{};
-template <class T> inline constexpr T ln10_v =       __illformed<T>{};
-template <class T> inline constexpr T sqrt2_v =      __illformed<T>{};
-template <class T> inline constexpr T sqrt3_v =      __illformed<T>{};
-template <class T> inline constexpr T inv_sqrt3_v =  __illformed<T>{};
-template <class T> inline constexpr T egamma_v =     __illformed<T>{};
-template <class T> inline constexpr T phi_v =        __illformed<T>{};
-
-template <floating_point T> inline constexpr T e_v<T>          = 2.718281828459045235360287471352662;
-template <floating_point T> inline constexpr T log2e_v<T>      = 1.442695040888963407359924681001892;
-template <floating_point T> inline constexpr T log10e_v<T>     = 0.434294481903251827651128918916605;
-template <floating_point T> inline constexpr T pi_v<T>         = 3.141592653589793238462643383279502;
-template <floating_point T> inline constexpr T inv_pi_v<T>     = 0.318309886183790671537767526745028;
-template <floating_point T> inline constexpr T inv_sqrtpi_v<T> = 0.564189583547756286948079451560772;
-template <floating_point T> inline constexpr T ln2_v<T>        = 0.693147180559945309417232121458176;
-template <floating_point T> inline constexpr T ln10_v<T>       = 2.302585092994045684017991454684364;
-template <floating_point T> inline constexpr T sqrt2_v<T>      = 1.414213562373095048801688724209698;
-template <floating_point T> inline constexpr T sqrt3_v<T>      = 1.732050807568877293527446341505872;
-template <floating_point T> inline constexpr T inv_sqrt3_v<T>  = 0.577350269189625764509148780501957;
-template <floating_point T> inline constexpr T egamma_v<T>     = 0.577215664901532860606512090082402;
-template <floating_point T> inline constexpr T phi_v<T>        = 1.618033988749894848204586834365638;
+template <class _Tp> inline constexpr _Tp e_v =          __illformed<_Tp>{};
+template <class _Tp> inline constexpr _Tp log2e_v =      __illformed<_Tp>{};
+template <class _Tp> inline constexpr _Tp log10e_v =     __illformed<_Tp>{};
+template <class _Tp> inline constexpr _Tp pi_v =         __illformed<_Tp>{};
+template <class _Tp> inline constexpr _Tp inv_pi_v =     __illformed<_Tp>{};
+template <class _Tp> inline constexpr _Tp inv_sqrtpi_v = __illformed<_Tp>{};
+template <class _Tp> inline constexpr _Tp ln2_v =        __illformed<_Tp>{};
+template <class _Tp> inline constexpr _Tp ln10_v =       __illformed<_Tp>{};
+template <class _Tp> inline constexpr _Tp sqrt2_v =      __illformed<_Tp>{};
+template <class _Tp> inline constexpr _Tp sqrt3_v =      __illformed<_Tp>{};
+template <class _Tp> inline constexpr _Tp inv_sqrt3_v =  __illformed<_Tp>{};
+template <class _Tp> inline constexpr _Tp egamma_v =     __illformed<_Tp>{};
+template <class _Tp> inline constexpr _Tp phi_v =        __illformed<_Tp>{};
+
+template <floating_point _Tp> inline constexpr _Tp e_v<_Tp>          = 2.718281828459045235360287471352662;
+template <floating_point _Tp> inline constexpr _Tp log2e_v<_Tp>      = 1.442695040888963407359924681001892;
+template <floating_point _Tp> inline constexpr _Tp log10e_v<_Tp>     = 0.434294481903251827651128918916605;
+template <floating_point _Tp> inline constexpr _Tp pi_v<_Tp>         = 3.141592653589793238462643383279502;
+template <floating_point _Tp> inline constexpr _Tp inv_pi_v<_Tp>     = 0.318309886183790671537767526745028;
+template <floating_point _Tp> inline constexpr _Tp inv_sqrtpi_v<_Tp> = 0.564189583547756286948079451560772;
+template <floating_point _Tp> inline constexpr _Tp ln2_v<_Tp>        = 0.693147180559945309417232121458176;
+template <floating_point _Tp> inline constexpr _Tp ln10_v<_Tp>       = 2.302585092994045684017991454684364;
+template <floating_point _Tp> inline constexpr _Tp sqrt2_v<_Tp>      = 1.414213562373095048801688724209698;
+template <floating_point _Tp> inline constexpr _Tp sqrt3_v<_Tp>      = 1.732050807568877293527446341505872;
+template <floating_point _Tp> inline constexpr _Tp inv_sqrt3_v<_Tp>  = 0.577350269189625764509148780501957;
+template <floating_point _Tp> inline constexpr _Tp egamma_v<_Tp>     = 0.577215664901532860606512090082402;
+template <floating_point _Tp> inline constexpr _Tp phi_v<_Tp>        = 1.618033988749894848204586834365638;
 
 inline constexpr double e          = e_v<double>;
 inline constexpr double log2e      = log2e_v<double>;
diff --git a/libcxx/include/optional b/libcxx/include/optional
--- a/libcxx/include/optional
+++ b/libcxx/include/optional
@@ -1167,8 +1167,8 @@
 };
 
 #if _LIBCPP_STD_VER >= 17
-template<class T>
-    optional(T) -> optional<T>;
+template<class _Tp>
+    optional(_Tp) -> optional<_Tp>;
 #endif
 
 // Comparisons between optionals
diff --git a/libcxx/include/type_traits b/libcxx/include/type_traits
--- a/libcxx/include/type_traits
+++ b/libcxx/include/type_traits
@@ -2318,7 +2318,7 @@
 // Clang provides variadic templates in C++03 as an extension.
 #if !defined(_LIBCPP_CXX03_LANG) || defined(__clang__)
 # define _LIBCPP_OPTIONAL_PACK(...) , __VA_ARGS__
-template <class... Tp>
+template <class... _Tp>
 struct __common_types;
 template <class... _Tp>
 struct _LIBCPP_TEMPLATE_VIS common_type;
diff --git a/libcxx/test/libcxx/alphabetic_macros.compile.pass.cpp b/libcxx/test/libcxx/alphabetic_macros.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/alphabetic_macros.compile.pass.cpp
@@ -0,0 +1,410 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// Test that headers are not tripped up by the surrounding code defining various
+// alphabetic macros.
+
+// Prevent <ext/hash_map> from generating deprecated warnings for this test.
+#if defined(__DEPRECATED)
+#    undef __DEPRECATED
+#endif
+
+// Support static_assert in C++03 mode.
+#include "test_macros.h"
+
+#define A 42
+#define Arg 42
+#define Args 42
+#define As 42
+#define B 42
+#define Bs 42
+#define C 42
+#define Cs 42
+#define R 42
+#define Rp 42
+#define T 42
+#define Tp 42
+#define Ts 42
+#define Type 42
+#define Types 42
+#define U 42
+#define Up 42
+#define Us 42
+#define V 42
+#define Vs 42
+#define X 42
+#define Xs 42
+
+#define TM(X) static_assert(X == 42, "");
+#define TEST_MACROS() \
+  TM(A) TM(Arg) TM(Args) TM(As) TM(B) TM(Bs) TM(C) TM(Cs)
+  TM(R) TM(Rp) TM(T) TM(Tp) TM(Ts) TM(Type) TM(Types)
+  TM(U) TM(Up) TM(Us) TM(V) TM(Vs) TM(X) TM(Xs)
+
+////////////////////////////////////////////////////////////////////////////////
+// BEGIN-GENERATED-HEADERS
+////////////////////////////////////////////////////////////////////////////////
+
+// clang-format off
+
+// WARNING: This test was generated by generate_header_tests.py
+// and should not be edited manually.
+
+// Top level headers
+#include <algorithm>
+TEST_MACROS();
+#include <any>
+TEST_MACROS();
+#include <array>
+TEST_MACROS();
+#include <atomic>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_THREADS
+#    include <barrier>
+TEST_MACROS();
+#endif
+#include <bit>
+TEST_MACROS();
+#include <bitset>
+TEST_MACROS();
+#include <cassert>
+TEST_MACROS();
+#include <ccomplex>
+TEST_MACROS();
+#include <cctype>
+TEST_MACROS();
+#include <cerrno>
+TEST_MACROS();
+#include <cfenv>
+TEST_MACROS();
+#include <cfloat>
+TEST_MACROS();
+#include <charconv>
+TEST_MACROS();
+#include <chrono>
+TEST_MACROS();
+#include <cinttypes>
+TEST_MACROS();
+#include <ciso646>
+TEST_MACROS();
+#include <climits>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#    include <clocale>
+TEST_MACROS();
+#endif
+#include <cmath>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#    include <codecvt>
+TEST_MACROS();
+#endif
+#include <compare>
+TEST_MACROS();
+#include <complex>
+TEST_MACROS();
+#include <complex.h>
+TEST_MACROS();
+#include <concepts>
+TEST_MACROS();
+#include <condition_variable>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_CXX20_COROUTINES
+#    include <coroutine>
+TEST_MACROS();
+#endif
+#include <csetjmp>
+TEST_MACROS();
+#include <csignal>
+TEST_MACROS();
+#include <cstdarg>
+TEST_MACROS();
+#include <cstdbool>
+TEST_MACROS();
+#include <cstddef>
+TEST_MACROS();
+#include <cstdint>
+TEST_MACROS();
+#include <cstdio>
+TEST_MACROS();
+#include <cstdlib>
+TEST_MACROS();
+#include <cstring>
+TEST_MACROS();
+#include <ctgmath>
+TEST_MACROS();
+#include <ctime>
+TEST_MACROS();
+#include <ctype.h>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#    include <cwchar>
+TEST_MACROS();
+#endif
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#    include <cwctype>
+TEST_MACROS();
+#endif
+#include <deque>
+TEST_MACROS();
+#include <errno.h>
+TEST_MACROS();
+#include <exception>
+TEST_MACROS();
+#include <execution>
+TEST_MACROS();
+#include <fenv.h>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+#    include <filesystem>
+TEST_MACROS();
+#endif
+#include <float.h>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_INCOMPLETE_FORMAT
+#    include <format>
+TEST_MACROS();
+#endif
+#include <forward_list>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#    include <fstream>
+TEST_MACROS();
+#endif
+#include <functional>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_THREADS
+#    include <future>
+TEST_MACROS();
+#endif
+#include <initializer_list>
+TEST_MACROS();
+#include <inttypes.h>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#    include <iomanip>
+TEST_MACROS();
+#endif
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#    include <ios>
+TEST_MACROS();
+#endif
+#include <iosfwd>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#    include <iostream>
+TEST_MACROS();
+#endif
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#    include <istream>
+TEST_MACROS();
+#endif
+#include <iterator>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_THREADS
+#    include <latch>
+TEST_MACROS();
+#endif
+#include <limits>
+TEST_MACROS();
+#include <limits.h>
+TEST_MACROS();
+#include <list>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#    include <locale>
+TEST_MACROS();
+#endif
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#    include <locale.h>
+TEST_MACROS();
+#endif
+#include <map>
+TEST_MACROS();
+#include <math.h>
+TEST_MACROS();
+#include <memory>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_THREADS
+#    include <mutex>
+TEST_MACROS();
+#endif
+#include <new>
+TEST_MACROS();
+#include <numbers>
+TEST_MACROS();
+#include <numeric>
+TEST_MACROS();
+#include <optional>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#    include <ostream>
+TEST_MACROS();
+#endif
+#include <queue>
+TEST_MACROS();
+#include <random>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_INCOMPLETE_RANGES
+#    include <ranges>
+TEST_MACROS();
+#endif
+#include <ratio>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#    include <regex>
+TEST_MACROS();
+#endif
+#include <scoped_allocator>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_THREADS
+#    include <semaphore>
+TEST_MACROS();
+#endif
+#include <set>
+TEST_MACROS();
+#include <setjmp.h>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_THREADS
+#    include <shared_mutex>
+TEST_MACROS();
+#endif
+#include <span>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#    include <sstream>
+TEST_MACROS();
+#endif
+#include <stack>
+TEST_MACROS();
+#include <stdbool.h>
+TEST_MACROS();
+#include <stddef.h>
+TEST_MACROS();
+#include <stdexcept>
+TEST_MACROS();
+#include <stdint.h>
+TEST_MACROS();
+#include <stdio.h>
+TEST_MACROS();
+#include <stdlib.h>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#    include <streambuf>
+TEST_MACROS();
+#endif
+#include <string>
+TEST_MACROS();
+#include <string.h>
+TEST_MACROS();
+#include <string_view>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#    include <strstream>
+TEST_MACROS();
+#endif
+#include <system_error>
+TEST_MACROS();
+#include <tgmath.h>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_THREADS
+#    include <thread>
+TEST_MACROS();
+#endif
+#include <tuple>
+TEST_MACROS();
+#include <type_traits>
+TEST_MACROS();
+#include <typeindex>
+TEST_MACROS();
+#include <typeinfo>
+TEST_MACROS();
+#include <unordered_map>
+TEST_MACROS();
+#include <unordered_set>
+TEST_MACROS();
+#include <utility>
+TEST_MACROS();
+#include <valarray>
+TEST_MACROS();
+#include <variant>
+TEST_MACROS();
+#include <vector>
+TEST_MACROS();
+#include <version>
+TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#    include <wchar.h>
+TEST_MACROS();
+#endif
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#    include <wctype.h>
+TEST_MACROS();
+#endif
+
+// experimental headers
+#if __cplusplus >= 201103L
+#    include <experimental/algorithm>
+TEST_MACROS();
+#    ifndef _LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES
+#        include <experimental/coroutine>
+TEST_MACROS();
+#    endif
+#    include <experimental/deque>
+TEST_MACROS();
+#    ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+#        include <experimental/filesystem>
+TEST_MACROS();
+#    endif
+#    include <experimental/forward_list>
+TEST_MACROS();
+#    include <experimental/functional>
+TEST_MACROS();
+#    include <experimental/iterator>
+TEST_MACROS();
+#    include <experimental/list>
+TEST_MACROS();
+#    include <experimental/map>
+TEST_MACROS();
+#    include <experimental/memory_resource>
+TEST_MACROS();
+#    include <experimental/propagate_const>
+TEST_MACROS();
+#    ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#        include <experimental/regex>
+TEST_MACROS();
+#    endif
+#    include <experimental/set>
+TEST_MACROS();
+#    include <experimental/simd>
+TEST_MACROS();
+#    include <experimental/string>
+TEST_MACROS();
+#    include <experimental/type_traits>
+TEST_MACROS();
+#    include <experimental/unordered_map>
+TEST_MACROS();
+#    include <experimental/unordered_set>
+TEST_MACROS();
+#    include <experimental/utility>
+TEST_MACROS();
+#    include <experimental/vector>
+TEST_MACROS();
+#endif // __cplusplus >= 201103L
+
+// extended headers
+#include <ext/hash_map>
+TEST_MACROS();
+#include <ext/hash_set>
+TEST_MACROS();
+
+// clang-format on
+
+////////////////////////////////////////////////////////////////////////////////
+// END-GENERATED-HEADERS
+////////////////////////////////////////////////////////////////////////////////
diff --git a/libcxx/utils/generate_header_tests.py b/libcxx/utils/generate_header_tests.py
--- a/libcxx/utils/generate_header_tests.py
+++ b/libcxx/utils/generate_header_tests.py
@@ -207,6 +207,8 @@
                  post_include='TEST_MACROS();')
     produce_test('no_assert_include.compile.pass.cpp',
                  exclusions=['cassert'])
+    produce_test('alphabetic_macros.compile.pass.cpp',
+                 post_include='TEST_MACROS();')
 
 
 if __name__ == '__main__':