[libcxx] [test] Fix Clang -Wunused-local-typedef, part 2/3.

[STL_MSFT]

Summary

[libcxx] [test] Fix Clang -Wunused-local-typedef, part 2/3.

These typedefs were completely unused.

test/std/containers/sequences/deque/deque.cons/size.pass.cpp

 }
 
 template <class T, class Allocator>
 void
 test3(unsigned n, Allocator const &alloc = Allocator())
 {
 #if TEST_STD_VER > 11
     typedef std::deque<T, Allocator> C;
-    typedef typename C::const_iterator const_iterator;
     {
     C d(n, alloc);
     assert(d.size() == n);
     assert(d.get_allocator() == alloc);
     }
 #else
     ((void)n);
     ((void)alloc);

test/std/containers/sequences/list/list.cons/size_type.pass.cpp

 #include "min_allocator.h"
 
 template <class T, class Allocator>
 void
 test3(unsigned n, Allocator const &alloc = Allocator())
 {
 #if TEST_STD_VER > 11
     typedef std::list<T, Allocator> C;
-    typedef typename C::const_iterator const_iterator;
     {
     C d(n, alloc);
     assert(d.size() == n);
     assert(static_cast<std::size_t>(std::distance(d.begin(), d.end())) == n);
     assert(d.get_allocator() == alloc);
     }
 #else
     ((void)n);

test/std/containers/unord/unord.multimap/bucket_count.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 
 int main()
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
-        typedef C::const_iterator I;
-        typedef std::pair<int, std::string> P;
         const C c;
         LIBCPP_ASSERT(c.bucket_count() == 0);
     }
     {
         typedef std::unordered_multimap<int, std::string> C;
-        typedef C::const_iterator I;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(10, "ten"),
             P(20, "twenty"),
             P(30, "thirty"),
             P(40, "forty"),
             P(50, "fifty"),
             P(60, "sixty"),
             P(70, "seventy"),
             P(80, "eighty"),
         };
         const C c(std::begin(a), std::end(a));
         assert(c.bucket_count() >= 8);
     }
 }

test/std/containers/unord/unord.multimap/load_factor.pass.cpp

int main()
             P(70, "seventy"),
             P(80, "eighty"),
         };
         const C c(std::begin(a), std::end(a));
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
     }
     {
         typedef std::unordered_multimap<int, std::string> C;
-        typedef std::pair<int, std::string> P;
         const C c;
         assert(c.load_factor() == 0);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         typedef std::pair<int, std::string> P;
#if TEST_STD_VER >= 11
             P(80, "eighty"),
         };
         const C c(std::begin(a), std::end(a));
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
     }
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
-        typedef std::pair<int, std::string> P;
         const C c;
         assert(c.load_factor() == 0);
     }
 #endif
 }

test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp

 #include <cassert>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
-        typedef C::const_iterator I;
-        typedef std::pair<int, std::string> P;
         const C c;
         assert(c.max_bucket_count() > 0);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
-        typedef C::const_iterator I;
-        typedef std::pair<int, std::string> P;
         const C c;
         assert(c.max_bucket_count() > 0);
     }
 #endif
 }

test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp

 #include <cassert>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
-        typedef std::pair<int, std::string> P;
         const C c;
         assert(c.max_load_factor() == 1);
     }
     {
         typedef std::unordered_multimap<int, std::string> C;
-        typedef std::pair<int, std::string> P;
         C c;
         assert(c.max_load_factor() == 1);
         c.max_load_factor(2.5);
         assert(c.max_load_factor() == 2.5);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
-        typedef std::pair<int, std::string> P;
         const C c;
         assert(c.max_load_factor() == 1);
     }
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
-        typedef std::pair<int, std::string> P;
         C c;
         assert(c.max_load_factor() == 1);
         c.max_load_factor(2.5);
         assert(c.max_load_factor() == 2.5);
     }
 #endif
 #if _LIBCPP_DEBUG_LEVEL >= 1
     {
         typedef std::unordered_multimap<int, std::string> C;
         C c;
         c.max_load_factor(0);
         assert(false);
     }
 #endif
 }

test/std/containers/unord/unord.multimap/swap_member.pass.cpp

 
 int main()
 {
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
-        typedef std::pair<int, std::string> P;
         C c1(0, Hash(1), Compare(1), Alloc(1, 1));
         C c2(0, Hash(2), Compare(2), Alloc(1, 2));
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
int main()
         assert(c2.max_load_factor() == 1);
     }
 
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
-        typedef std::pair<int, std::string> P;
         C c1(0, Hash(1), Compare(1), Alloc(1));
         C c2(0, Hash(2), Compare(2), Alloc(2));
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
int main()
         assert(c2.max_load_factor() == 1);
     }
 #if TEST_STD_VER >= 11
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
-        typedef std::pair<int, std::string> P;
         C c1(0, Hash(1), Compare(1), Alloc());
         C c2(0, Hash(2), Compare(2), Alloc());
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));

test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp

 
 int main()
 {
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
-        typedef std::pair<int, std::string> P;
         C c1(0, Hash(1), Compare(1), Alloc(1, 1));
         C c2(0, Hash(2), Compare(2), Alloc(1, 2));
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
int main()
         assert(c2.max_load_factor() == 1);
     }
 
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
-        typedef std::pair<int, std::string> P;
         C c1(0, Hash(1), Compare(1), Alloc(1));
         C c2(0, Hash(2), Compare(2), Alloc(2));
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
int main()
         assert(c2.max_load_factor() == 1);
     }
 #if TEST_STD_VER >= 11
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
-        typedef std::pair<int, std::string> P;
         C c1(0, Hash(1), Compare(1), Alloc());
         C c2(0, Hash(2), Compare(2), Alloc());
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));

test/std/containers/unord/unord.multiset/bucket_count.pass.cpp

 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef std::unordered_multiset<int> C;
-        typedef C::const_iterator I;
-        typedef int P;
         const C c;
         LIBCPP_ASSERT(c.bucket_count() == 0);
     }
     {
         typedef std::unordered_multiset<int> C;
-        typedef C::const_iterator I;
         typedef int P;
         P a[] =
         {
             P(10),
             P(20),
             P(30),
             P(40),
             P(50),
             P(60),
             P(70),
             P(80)
         };
         const C c(std::begin(a), std::end(a));
         assert(c.bucket_count() >= 8);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
-        typedef C::const_iterator I;
-        typedef int P;
         const C c;
         LIBCPP_ASSERT(c.bucket_count() == 0);
     }
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
-        typedef C::const_iterator I;
         typedef int P;
         P a[] =
         {
             P(10),
             P(20),
             P(30),
             P(40),
             P(50),

test/std/containers/unord/unord.multiset/load_factor.pass.cpp

int main()
             P(70),
             P(80)
         };
         const C c(std::begin(a), std::end(a));
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
     }
     {
         typedef std::unordered_multiset<int> C;
-        typedef int P;
         const C c;
         assert(c.load_factor() == 0);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
#if TEST_STD_VER >= 11
             P(80)
         };
         const C c(std::begin(a), std::end(a));
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
     }
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
-        typedef int P;
         const C c;
         assert(c.load_factor() == 0);
     }
 #endif
 }

test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp

 #include <cassert>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef std::unordered_multiset<int> C;
-        typedef int P;
         const C c;
         assert(c.max_load_factor() == 1);
     }
     {
         typedef std::unordered_multiset<int> C;
-        typedef int P;
         C c;
         assert(c.max_load_factor() == 1);
         c.max_load_factor(2.5);
         assert(c.max_load_factor() == 2.5);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
-        typedef int P;
         const C c;
         assert(c.max_load_factor() == 1);
     }
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
-        typedef int P;
         C c;
         assert(c.max_load_factor() == 1);
         c.max_load_factor(2.5);
         assert(c.max_load_factor() == 2.5);
     }
 #endif
 #if _LIBCPP_DEBUG_LEVEL >= 1
     {
         typedef std::unordered_multiset<int> C;
         C c;
         c.max_load_factor(0);
         assert(false);
     }
 #endif
 }

test/std/containers/unord/unord.multiset/swap_member.pass.cpp

 
 int main()
 {
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
-        typedef int P;
         C c1(0, Hash(1), Compare(1), Alloc(1, 1));
         C c2(0, Hash(2), Compare(2), Alloc(1, 2));
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
int main()
         assert(c2.max_load_factor() == 1);
     }
 
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
-        typedef int P;
         C c1(0, Hash(1), Compare(1), Alloc(1));
         C c2(0, Hash(2), Compare(2), Alloc(2));
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
int main()
         assert(c2.max_load_factor() == 1);
     }
 #if TEST_STD_VER >= 11
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
-        typedef int P;
         C c1(0, Hash(1), Compare(1), Alloc());
         C c2(0, Hash(2), Compare(2), Alloc());
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));

test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp

 
 int main()
 {
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
-        typedef int P;
         C c1(0, Hash(1), Compare(1), Alloc(1, 1));
         C c2(0, Hash(2), Compare(2), Alloc(1, 2));
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
int main()
         assert(c2.max_load_factor() == 1);
     }
 
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
-        typedef int P;
         C c1(0, Hash(1), Compare(1), Alloc(1));
         C c2(0, Hash(2), Compare(2), Alloc(2));
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
int main()
         assert(c2.max_load_factor() == 1);
     }
 #if TEST_STD_VER >= 11
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
-        typedef int P;
         C c1(0, Hash(1), Compare(1), Alloc());
         C c2(0, Hash(2), Compare(2), Alloc());
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));

test/std/containers/unord/unord.set/bucket_count.pass.cpp

 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef std::unordered_set<int> C;
-        typedef C::const_iterator I;
-        typedef int P;
         const C c;
         LIBCPP_ASSERT(c.bucket_count() == 0);
     }
     {
         typedef std::unordered_set<int> C;
-        typedef C::const_iterator I;
         typedef int P;
         P a[] =
         {
             P(10),
             P(20),
             P(30),
             P(40),
             P(50),
             P(60),
             P(70),
             P(80)
         };
         const C c(std::begin(a), std::end(a));
         assert(c.bucket_count() >= 8);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
-        typedef C::const_iterator I;
-        typedef int P;
         const C c;
         LIBCPP_ASSERT(c.bucket_count() == 0);
     }
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
-        typedef C::const_iterator I;
         typedef int P;
         P a[] =
         {
             P(10),
             P(20),
             P(30),
             P(40),
             P(50),

test/std/containers/unord/unord.set/load_factor.pass.cpp

int main()
             P(70),
             P(80)
         };
         const C c(std::begin(a), std::end(a));
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
     }
     {
         typedef std::unordered_set<int> C;
-        typedef int P;
         const C c;
         assert(c.load_factor() == 0);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
#if TEST_STD_VER >= 11
             P(80)
         };
         const C c(std::begin(a), std::end(a));
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
     }
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
-        typedef int P;
         const C c;
         assert(c.load_factor() == 0);
     }
 #endif
 }

test/std/containers/unord/unord.set/max_load_factor.pass.cpp

 #include <cassert>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef std::unordered_set<int> C;
-        typedef int P;
         const C c;
         assert(c.max_load_factor() == 1);
     }
     {
         typedef std::unordered_set<int> C;
-        typedef int P;
         C c;
         assert(c.max_load_factor() == 1);
         c.max_load_factor(2.5);
         assert(c.max_load_factor() == 2.5);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
-        typedef int P;
         const C c;
         assert(c.max_load_factor() == 1);
     }
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
-        typedef int P;
         C c;
         assert(c.max_load_factor() == 1);
         c.max_load_factor(2.5);
         assert(c.max_load_factor() == 2.5);
     }
 #endif
 #if _LIBCPP_DEBUG_LEVEL >= 1
     {
         typedef std::unordered_set<int> C;
         C c;
         c.max_load_factor(-0.5f);
         assert(false);
     }
 #endif
 }

test/std/containers/unord/unord.set/swap_member.pass.cpp

 
 int main()
 {
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
-        typedef int P;
         C c1(0, Hash(1), Compare(1), Alloc(1, 1));
         C c2(0, Hash(2), Compare(2), Alloc(1, 2));
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
int main()
         assert(c2.max_load_factor() == 1);
     }
 
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
-        typedef int P;
         C c1(0, Hash(1), Compare(1), Alloc(1));
         C c2(0, Hash(2), Compare(2), Alloc(2));
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
int main()
         assert(c2.max_load_factor() == 1);
     }
 #if TEST_STD_VER >= 11
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
-        typedef int P;
         C c1(0, Hash(1), Compare(1), Alloc());
         C c2(0, Hash(2), Compare(2), Alloc());
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));

test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp

 
 int main()
 {
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
-        typedef int P;
         C c1(0, Hash(1), Compare(1), Alloc(1, 1));
         C c2(0, Hash(2), Compare(2), Alloc(1, 2));
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
int main()
         assert(c2.max_load_factor() == 1);
     }
 
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
-        typedef int P;
         C c1(0, Hash(1), Compare(1), Alloc(1));
         C c2(0, Hash(2), Compare(2), Alloc(2));
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
int main()
         assert(c2.max_load_factor() == 1);
     }
 #if TEST_STD_VER >= 11
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
-        typedef int P;
         C c1(0, Hash(1), Compare(1), Alloc());
         C c2(0, Hash(2), Compare(2), Alloc());
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));

test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp

 void
 test()
 {
     test(std::complex<T>(0, 0), std::complex<T>(0, 0));
 }
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         std::complex<double> r = atan(testcases[i]);
         std::complex<double> t1(-imag(testcases[i]), real(testcases[i]));
         std::complex<double> t2 = atanh(t1);
         std::complex<double> z(imag(t2), -real(t2));
         if (std::isnan(real(r)))

test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp

 test()
 {
     test(std::complex<T>(0, 0), std::complex<T>(0, 0));
     test(std::complex<T>(10000, -10000), std::complex<T>(0, -1));
 }
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         std::complex<double> r = tan(testcases[i]);
         std::complex<double> t1(-imag(testcases[i]), real(testcases[i]));
         std::complex<double> t2 = tanh(t1);
         std::complex<double> z(imag(t2), -real(t2));
         if (std::isnan(real(r)))

test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp

 {
     return 1/3.1415926535897932 * std::atan((x - a)/b) + .5;
 }
 
 int main()
 {
     {
         typedef std::cauchy_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         const double a = 10;
         const double b = .5;
         D d(a, b);
         const int N = 1000000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
             u.push_back(d(g));
         std::sort(u.begin(), u.end());
         for (int i = 0; i < N; ++i)
             assert(std::abs(f(u[i], a, b) - double(i)/N) < .001);
     }
     {
         typedef std::cauchy_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         const double a = -1.5;
         const double b = 1;
         D d(a, b);
         const int N = 1000000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
             u.push_back(d(g));
         std::sort(u.begin(), u.end());
         for (int i = 0; i < N; ++i)
             assert(std::abs(f(u[i], a, b) - double(i)/N) < .001);
     }
     {
         typedef std::cauchy_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         const double a = .5;
         const double b = 2;
         D d(a, b);
         const int N = 1000000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
             u.push_back(d(g));
         std::sort(u.begin(), u.end());
         for (int i = 0; i < N; ++i)
             assert(std::abs(f(u[i], a, b) - double(i)/N) < .001);
     }
 }

test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp

 {
     return x * x;
 }
 
 int main()
 {
     {
         typedef std::chi_squared_distribution<> D;
-        typedef D::param_type P;
         typedef std::minstd_rand G;
         G g;
         D d(0.5);
         const int N = 1000000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g);
int main()
         double x_kurtosis = 12 / d.n();
         assert(std::abs((mean - x_mean) / x_mean) < 0.01);
         assert(std::abs((var - x_var) / x_var) < 0.01);
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
     {
         typedef std::chi_squared_distribution<> D;
-        typedef D::param_type P;
         typedef std::minstd_rand G;
         G g;
         D d(1);
         const int N = 1000000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g);
int main()
         double x_kurtosis = 12 / d.n();
         assert(std::abs((mean - x_mean) / x_mean) < 0.01);
         assert(std::abs((var - x_var) / x_var) < 0.01);
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
     {
         typedef std::chi_squared_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(2);
         const int N = 1000000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g);

test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval.pass.cpp

f(double x, double m, double n)
     return I(m * x / (m*x + n), static_cast<unsigned>(m/2), static_cast<unsigned>(n/2));
 }
 
 int main()
 {
     // Purposefully only testing even integral values of m and n (for now)
     {
         typedef std::fisher_f_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(2, 4);
         const int N = 100000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g);
             assert(v >= 0);
             u.push_back(v);
         }
         std::sort(u.begin(), u.end());
         for (int i = 0; i < N; ++i)
             assert(std::abs(f(u[i], d.m(), d.n()) - double(i)/N) < .01);
     }
     {
         typedef std::fisher_f_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(4, 2);
         const int N = 100000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g);
             assert(v >= 0);
             u.push_back(v);
         }
         std::sort(u.begin(), u.end());
         for (int i = 0; i < N; ++i)
             assert(std::abs(f(u[i], d.m(), d.n()) - double(i)/N) < .01);
     }
     {
         typedef std::fisher_f_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(18, 20);
         const int N = 100000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g);
             assert(v >= 0);
             u.push_back(v);
         }
         std::sort(u.begin(), u.end());
         for (int i = 0; i < N; ++i)
             assert(std::abs(f(u[i], d.m(), d.n()) - double(i)/N) < .01);
     }
 }

test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp

 {
     return x * x;
 }
 
 int main()
 {
     {
         typedef std::normal_distribution<> D;
-        typedef D::param_type P;
         typedef std::minstd_rand G;
         G g;
         D d(5, 4);
         const int N = 1000000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
             u.push_back(d(g));
         double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();

test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp

 {
     return x * x;
 }
 
 int main()
 {
     {
         typedef std::exponential_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(.75);
         const int N = 1000000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g);
int main()
         double x_kurtosis = 6;
         assert(std::abs((mean - x_mean) / x_mean) < 0.01);
         assert(std::abs((var - x_var) / x_var) < 0.01);
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
     {
         typedef std::exponential_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(1);
         const int N = 1000000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g);
int main()
         double x_kurtosis = 6;
         assert(std::abs((mean - x_mean) / x_mean) < 0.01);
         assert(std::abs((var - x_var) / x_var) < 0.01);
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
     {
         typedef std::exponential_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(10);
         const int N = 1000000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g);

test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval.pass.cpp

 {
     return x * x;
 }
 
 int main()
 {
     {
         typedef std::weibull_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(0.5, 2);
         const int N = 1000000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g);
int main()
                        6*sqr(x_mean)*x_var - sqr(sqr(x_mean))) / sqr(x_var) - 3;
         assert(std::abs((mean - x_mean) / x_mean) < 0.01);
         assert(std::abs((var - x_var) / x_var) < 0.01);
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
     }
     {
         typedef std::weibull_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(1, .5);
         const int N = 1000000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g);
int main()
                        6*sqr(x_mean)*x_var - sqr(sqr(x_mean))) / sqr(x_var) - 3;
         assert(std::abs((mean - x_mean) / x_mean) < 0.01);
         assert(std::abs((var - x_var) / x_var) < 0.01);
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
     {
         typedef std::weibull_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(2, 3);
         const int N = 1000000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g);

test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp

 #include "min_allocator.h"
 
 template <class It>
 void
 test(It first, It last)
 {
     typedef typename std::iterator_traits<It>::value_type charT;
     typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
-    typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
     S s2(first, last);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
     unsigned i = 0;
     for (It it = first; it != last; ++it, ++i)
         assert(s2[i] == *it);
     assert(s2.get_allocator() == A());
     assert(s2.capacity() >= s2.size());
 }
 
 template <class It, class A>
 void
 test(It first, It last, const A& a)
 {
     typedef typename std::iterator_traits<It>::value_type charT;
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
-    typedef typename S::traits_type T;
     S s2(first, last, a);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
     unsigned i = 0;
     for (It it = first; it != last; ++it, ++i)
         assert(s2[i] == *it);
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());

test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp

test(const charT* s, const A& a)
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
 }
 
 int main()
 {
     {
     typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
 
     test("");
     test("", A(2));
 
     test("1");
     test("1", A(2));
 
     test("1234567980");
     test("1234567980", A(2));
 
     test("123456798012345679801234567980123456798012345679801234567980");
     test("123456798012345679801234567980123456798012345679801234567980", A(2));
     }
 #if TEST_STD_VER >= 11
     {
     typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
 
     test("");
     test("", A());
 
     test("1");
     test("1", A());
 
     test("1234567980");
     test("1234567980", A());
 
     test("123456798012345679801234567980123456798012345679801234567980");
     test("123456798012345679801234567980123456798012345679801234567980", A());
     }
 #endif
 }

test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp

test(const charT* s, unsigned n, const A& a)
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
 }
 
 int main()
 {
     {
     typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
 
     test("", 0);
     test("", 0, A(2));
 
     test("1", 1);
     test("1", 1, A(2));
 
     test("1234567980", 10);
     test("1234567980", 10, A(2));
 
     test("123456798012345679801234567980123456798012345679801234567980", 60);
     test("123456798012345679801234567980123456798012345679801234567980", 60, A(2));
     }
 #if TEST_STD_VER >= 11
     {
     typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
 
     test("", 0);
     test("", 0, A());
 
     test("1", 1);
     test("1", 1, A());
 
     test("1234567980", 10);
     test("1234567980", 10, A());
 
     test("123456798012345679801234567980123456798012345679801234567980", 60);
     test("123456798012345679801234567980123456798012345679801234567980", 60, A());
     }
 #endif
 }

test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp

 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class charT>
 void
 test(unsigned n, charT c)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
-    typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
     S s2(n, c);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     for (unsigned i = 0; i < n; ++i)
         assert(s2[i] == c);
     assert(s2.get_allocator() == A());
     assert(s2.capacity() >= s2.size());
 }
 
 template <class charT, class A>
 void
 test(unsigned n, charT c, const A& a)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
-    typedef typename S::traits_type T;
     S s2(n, c, a);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     for (unsigned i = 0; i < n; ++i)
         assert(s2[i] == c);
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
 }
 
 template <class Tp>
 void
 test(Tp n, Tp c)
 {
     typedef char charT;
     typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
-    typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
     S s2(n, c);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == static_cast<std::size_t>(n));
     for (int i = 0; i < n; ++i)
         assert(s2[i] == c);
     assert(s2.get_allocator() == A());
     assert(s2.capacity() >= s2.size());
 }
 
 template <class Tp, class A>
 void
 test(Tp n, Tp c, const A& a)
 {
     typedef char charT;
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
-    typedef typename S::traits_type T;
     S s2(n, c, a);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == static_cast<std::size_t>(n));
     for (int i = 0; i < n; ++i)
         assert(s2[i] == c);
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
 }
 
 int main()
 {
     {
     typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
 
     test(0, 'a');
     test(0, 'a', A(2));
 
     test(1, 'a');
     test(1, 'a', A(2));
 
     test(10, 'a');
     test(10, 'a', A(2));
 
     test(100, 'a');
     test(100, 'a', A(2));
 
     test(static_cast<char>(100), static_cast<char>(65));
     test(static_cast<char>(100), static_cast<char>(65), A(3));
     }
 #if TEST_STD_VER >= 11
     {
     typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
 
     test(0, 'a');
     test(0, 'a', A());
 
     test(1, 'a');
     test(1, 'a', A());
 
     test(10, 'a');

test/std/strings/basic.string/string.cons/substr.pass.cpp

 #endif
 }
 
 template <class S>
 void
 test(S str, unsigned pos, unsigned n, const typename S::allocator_type& a)
 {
     typedef typename S::traits_type T;
-    typedef typename S::allocator_type A;
 
     if (pos <= str.size())
     {
         S s2(str, pos, n, a);
         LIBCPP_ASSERT(s2.__invariants());
         typename S::size_type rlen = std::min<typename S::size_type>(str.size() - pos, n);
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);

test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp

P.reset();
                    >(CA, ptr)));
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 
 void test_with_inner_alloc()
 {
-    using VoidAlloc1 = CountingAllocator<void, 1>;
     using VoidAlloc2 = CountingAllocator<void, 2>;
 
     AllocController POuter;
     AllocController PInner;
     {
         using T = UsesAllocatorV1<VoidAlloc2, 1>;
         using U = UsesAllocatorV2<VoidAlloc2, 1>;
         using Pair = std::pair<T, U>;

test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp

P.reset();
                    >(CA, ptr)));
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 
 void test_with_inner_alloc()
 {
-    using VoidAlloc1 = CountingAllocator<void, 1>;
     using VoidAlloc2 = CountingAllocator<void, 2>;
 
     AllocController POuter;
     AllocController PInner;
     {
         using T = UsesAllocatorV1<VoidAlloc2, 1>;
         using U = UsesAllocatorV2<VoidAlloc2, 1>;
         using Pair = std::pair<T, U>;

test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp

P.reset();
                    >(CA, ptr)));
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 
 void test_with_inner_alloc()
 {
-    using VoidAlloc1 = CountingAllocator<void, 1>;
     using VoidAlloc2 = CountingAllocator<void, 2>;
 
     AllocController POuter;
     AllocController PInner;
     {
         using T = UsesAllocatorV1<VoidAlloc2, 1>;
         using U = UsesAllocatorV2<VoidAlloc2, 1>;
         using Pair = std::pair<T, U>;

test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp

P.reset();
                    >(CA, ptr)));
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 
 void test_with_inner_alloc()
 {
-    using VoidAlloc1 = CountingAllocator<void, 1>;
     using VoidAlloc2 = CountingAllocator<void, 2>;
 
     AllocController POuter;
     AllocController PInner;
     {
         using T = UsesAllocatorV1<VoidAlloc2, 1>;
         using U = UsesAllocatorV2<VoidAlloc2, 1>;
         using Pair = std::pair<T, U>;

test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp

 #include "uses_alloc_types.hpp"
 #include "controlled_allocators.hpp"
 
 // — If uses_allocator_v<T, inner_allocator_type> is false and
 //   is_constructible_v<T, Args...> is true, calls
 //   OUTERMOST_ALLOC_TRAITS(*this)::construct(
 //      OUTERMOST (*this), p, std::forward<Args>(args)...).
 void test_bullet_one() {
-    using VoidAlloc1 = CountingAllocator<void, 1>;
     using VoidAlloc2 = CountingAllocator<void, 2>;
 
     AllocController POuter;
     AllocController PInner;
     {
         using T = NotUsesAllocator<VoidAlloc2, 3>;
         using Outer = CountingAllocator<T, 1>;
         using Inner = CountingAllocator<T, 2>;
         using SA = std::scoped_allocator_adaptor<Outer, Inner>;
-        using SAInner = std::scoped_allocator_adaptor<Inner>;
         static_assert(!std::uses_allocator<T, Outer>::value, "");
         static_assert(!std::uses_allocator<T, Inner>::value, "");
         T* ptr = (T*)::operator new(sizeof(T));
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         int x = 42;
         int const& cx = x;
         A.construct(ptr, x, cx, std::move(x));
         assert((checkConstruct<int&, int const&, int&&>(*ptr, UA_None)));
         assert((POuter.checkConstruct<int&, int const&, int&&>(O, ptr)));
         A.destroy(ptr);
         ::operator delete((void*)ptr);
     }
     PInner.reset();
     POuter.reset();
 }
 
 
 // Otherwise, if uses_allocator_v<T, inner_allocator_type> is true and
 // is_constructible_v<T, allocator_arg_t, inner_allocator_type&, Args...> is
 // true, calls OUTERMOST_ALLOC_TRAITS(*this)::construct(OUTERMOST (*this), p,
 //     allocator_arg, inner_allocator(), std::forward<Args>(args)...).
 void test_bullet_two() {
-    using VoidAlloc1 = CountingAllocator<void, 1>;
     using VoidAlloc2 = CountingAllocator<void, 2>;
 
     AllocController POuter;
     AllocController PInner;
     {
         using T = UsesAllocatorV1<VoidAlloc2, 3>;
         using Outer = CountingAllocator<T, 1>;
         using Inner = CountingAllocator<T, 2>;
         using SA = std::scoped_allocator_adaptor<Outer, Inner>;
-        using SAInner = std::scoped_allocator_adaptor<Inner>;
         static_assert(!std::uses_allocator<T, Outer>::value, "");
         static_assert(std::uses_allocator<T, Inner>::value, "");
         T* ptr = (T*)::operator new(sizeof(T));
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         int x = 42;
         int const& cx = x;
         A.construct(ptr, x, cx, std::move(x));
         assert((checkConstruct<int&, int const&, int&&>(*ptr, UA_AllocArg, I)));
         assert((POuter.checkConstruct<std::allocator_arg_t const&,
                    SA::inner_allocator_type&, int&, int const&, int&&>(O, ptr)));
         A.destroy(ptr);
         ::operator delete((void*)ptr);
     }
     PInner.reset();
     POuter.reset();
 }
 
 // Otherwise, if uses_allocator_v<T, inner_allocator_type> is true and
 // is_constructible_v<T, Args..., inner_allocator_type&> is true, calls
 // OUTERMOST_ALLOC_TRAITS(*this)::construct(OUTERMOST (*this), p,
 //   std::forward<Args>(args)..., inner_allocator()).
 void test_bullet_three() {
-    using VoidAlloc1 = CountingAllocator<void, 1>;
     using VoidAlloc2 = CountingAllocator<void, 2>;
 
     AllocController POuter;
     AllocController PInner;
     {
         using T = UsesAllocatorV2<VoidAlloc2, 3>;
         using Outer = CountingAllocator<T, 1>;
         using Inner = CountingAllocator<T, 2>;
         using SA = std::scoped_allocator_adaptor<Outer, Inner>;
-        using SAInner = std::scoped_allocator_adaptor<Inner>;
         static_assert(!std::uses_allocator<T, Outer>::value, "");
         static_assert(std::uses_allocator<T, Inner>::value, "");
         T* ptr = (T*)::operator new(sizeof(T));
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         int x = 42;
         int const& cx = x;

test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp

constexpr bool explicit_conversion(Input&& in, const Expect& v)
     static_assert(!std::is_constructible<O, Input, int>::value, "");
     optional<To> opt(std::forward<Input>(in));
     return opt && *opt == static_cast<To>(v);
 }
 
 void test_implicit()
 {
     {
-        using T = long long;
         static_assert(implicit_conversion<long long>(42, 42), "");
     }
     {
-        using T = long double;
         static_assert(implicit_conversion<long double>(3.14, 3.14), "");
     }
     {
         int x = 42;
         optional<void* const> o(&x);
         assert(*o == &x);
     }
     {
#ifndef TEST_HAS_NO_EXCEPTIONS
         }
     }
 #endif
 }
 
 void test_explicit() {
     {
         using T = ExplicitTrivialTestTypes::TestType;
-        using O = optional<T>;
         static_assert(explicit_conversion<T>(42, 42), "");
     }
     {
         using T = ExplicitConstexprTestTypes::TestType;
-        using O = optional<T>;
         static_assert(explicit_conversion<T>(42, 42), "");
         static_assert(!std::is_convertible<int, T>::value, "");
     }
     {
         using T = ExplicitTestTypes::TestType;
-        using O = optional<T>;
         T::reset();
         {
             assert(explicit_conversion<T>(42, 42));
             assert(T::alive == 0);
         }
         T::reset();
         {
             optional<T> t(42);