Index: test/std/containers/sequences/deque/deque.cons/size.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/size.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/size.pass.cpp
@@ -68,7 +68,6 @@
 {
 #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);
Index: test/std/containers/sequences/list/list.cons/size_type.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/size_type.pass.cpp
+++ test/std/containers/sequences/list/list.cons/size_type.pass.cpp
@@ -25,7 +25,6 @@
 {
 #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);
Index: test/std/containers/unord/unord.multimap/bucket_count.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/bucket_count.pass.cpp
+++ test/std/containers/unord/unord.multimap/bucket_count.pass.cpp
@@ -25,14 +25,11 @@
 {
     {
         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[] =
         {
Index: test/std/containers/unord/unord.multimap/load_factor.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/load_factor.pass.cpp
+++ test/std/containers/unord/unord.multimap/load_factor.pass.cpp
@@ -44,7 +44,6 @@
     }
     {
         typedef std::unordered_multimap<int, std::string> C;
-        typedef std::pair<int, std::string> P;
         const C c;
         assert(c.load_factor() == 0);
     }
@@ -70,7 +69,6 @@
     {
         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);
     }
Index: test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp
+++ test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp
@@ -25,8 +25,6 @@
 {
     {
         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);
     }
@@ -34,8 +32,6 @@
     {
         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);
     }
Index: test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp
+++ test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp
@@ -30,13 +30,11 @@
 {
     {
         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);
@@ -46,14 +44,12 @@
     {
         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);
Index: test/std/containers/unord/unord.multimap/swap_member.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/swap_member.pass.cpp
+++ test/std/containers/unord/unord.multimap/swap_member.pass.cpp
@@ -34,7 +34,6 @@
         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);
@@ -219,7 +218,6 @@
         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);
@@ -404,7 +402,6 @@
         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);
Index: test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
@@ -33,7 +33,6 @@
         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);
@@ -218,7 +217,6 @@
         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);
@@ -403,7 +401,6 @@
         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);
Index: test/std/containers/unord/unord.multiset/bucket_count.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/bucket_count.pass.cpp
+++ test/std/containers/unord/unord.multiset/bucket_count.pass.cpp
@@ -25,14 +25,11 @@
 {
     {
         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[] =
         {
@@ -52,15 +49,12 @@
     {
         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[] =
         {
Index: test/std/containers/unord/unord.multiset/load_factor.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/load_factor.pass.cpp
+++ test/std/containers/unord/unord.multiset/load_factor.pass.cpp
@@ -43,7 +43,6 @@
     }
     {
         typedef std::unordered_multiset<int> C;
-        typedef int P;
         const C c;
         assert(c.load_factor() == 0);
     }
@@ -69,7 +68,6 @@
     {
         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);
     }
Index: test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp
+++ test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp
@@ -29,13 +29,11 @@
 {
     {
         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);
@@ -45,14 +43,12 @@
     {
         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);
Index: test/std/containers/unord/unord.multiset/swap_member.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/swap_member.pass.cpp
+++ test/std/containers/unord/unord.multiset/swap_member.pass.cpp
@@ -32,7 +32,6 @@
         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);
@@ -213,7 +212,6 @@
         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);
@@ -394,7 +392,6 @@
         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);
Index: test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
@@ -32,7 +32,6 @@
         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);
@@ -213,7 +212,6 @@
         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);
@@ -394,7 +392,6 @@
         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);
Index: test/std/containers/unord/unord.set/bucket_count.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/bucket_count.pass.cpp
+++ test/std/containers/unord/unord.set/bucket_count.pass.cpp
@@ -25,14 +25,11 @@
 {
     {
         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[] =
         {
@@ -51,14 +48,11 @@
 #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[] =
         {
Index: test/std/containers/unord/unord.set/load_factor.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/load_factor.pass.cpp
+++ test/std/containers/unord/unord.set/load_factor.pass.cpp
@@ -43,7 +43,6 @@
     }
     {
         typedef std::unordered_set<int> C;
-        typedef int P;
         const C c;
         assert(c.load_factor() == 0);
     }
@@ -69,7 +68,6 @@
     {
         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);
     }
Index: test/std/containers/unord/unord.set/max_load_factor.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/max_load_factor.pass.cpp
+++ test/std/containers/unord/unord.set/max_load_factor.pass.cpp
@@ -29,13 +29,11 @@
 {
     {
         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);
@@ -45,14 +43,12 @@
     {
         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);
Index: test/std/containers/unord/unord.set/swap_member.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/swap_member.pass.cpp
+++ test/std/containers/unord/unord.set/swap_member.pass.cpp
@@ -32,7 +32,6 @@
         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);
@@ -213,7 +212,6 @@
         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);
@@ -394,7 +392,6 @@
         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);
Index: test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
@@ -32,7 +32,6 @@
         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);
@@ -213,7 +212,6 @@
         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);
@@ -394,7 +392,6 @@
         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);
Index: test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
+++ test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
@@ -34,7 +34,6 @@
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
Index: test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
+++ test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
@@ -35,7 +35,6 @@
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp
@@ -31,7 +31,6 @@
 {
     {
         typedef std::cauchy_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         const double a = 10;
@@ -47,7 +46,6 @@
     }
     {
         typedef std::cauchy_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         const double a = -1.5;
@@ -63,7 +61,6 @@
     }
     {
         typedef std::cauchy_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         const double a = .5;
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp
@@ -34,7 +34,6 @@
 {
     {
         typedef std::chi_squared_distribution<> D;
-        typedef D::param_type P;
         typedef std::minstd_rand G;
         G g;
         D d(0.5);
@@ -74,7 +73,6 @@
     }
     {
         typedef std::chi_squared_distribution<> D;
-        typedef D::param_type P;
         typedef std::minstd_rand G;
         G g;
         D d(1);
@@ -114,7 +112,6 @@
     }
     {
         typedef std::chi_squared_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(2);
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval.pass.cpp
@@ -51,7 +51,6 @@
     // 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);
@@ -69,7 +68,6 @@
     }
     {
         typedef std::fisher_f_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(4, 2);
@@ -87,7 +85,6 @@
     }
     {
         typedef std::fisher_f_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(18, 20);
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp
@@ -34,7 +34,6 @@
 {
     {
         typedef std::normal_distribution<> D;
-        typedef D::param_type P;
         typedef std::minstd_rand G;
         G g;
         D d(5, 4);
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp
@@ -34,7 +34,6 @@
 {
     {
         typedef std::exponential_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(.75);
@@ -74,7 +73,6 @@
     }
     {
         typedef std::exponential_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(1);
@@ -114,7 +112,6 @@
     }
     {
         typedef std::exponential_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(10);
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval.pass.cpp
@@ -34,7 +34,6 @@
 {
     {
         typedef std::weibull_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(0.5, 2);
@@ -78,7 +77,6 @@
     }
     {
         typedef std::weibull_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(1, .5);
@@ -122,7 +120,6 @@
     }
     {
         typedef std::weibull_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(2, 3);
Index: test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
+++ test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
@@ -29,7 +29,6 @@
 {
     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());
@@ -47,7 +46,6 @@
 {
     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)));
Index: test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
+++ test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
@@ -56,7 +56,6 @@
 {
     {
     typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
 
     test("");
     test("", A(2));
@@ -73,7 +72,6 @@
 #if TEST_STD_VER >= 11
     {
     typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
 
     test("");
     test("", A());
Index: test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
+++ test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
@@ -53,7 +53,6 @@
 {
     {
     typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
 
     test("", 0);
     test("", 0, A(2));
@@ -70,7 +69,6 @@
 #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());
Index: test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
+++ test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
@@ -26,7 +26,6 @@
 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());
@@ -42,7 +41,6 @@
 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);
@@ -58,7 +56,6 @@
 {
     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());
@@ -75,7 +72,6 @@
 {
     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));
@@ -89,7 +85,6 @@
 {
     {
     typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
 
     test(0, 'a');
     test(0, 'a', A(2));
@@ -109,7 +104,6 @@
 #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());
Index: test/std/strings/basic.string/string.cons/substr.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/substr.pass.cpp
+++ test/std/strings/basic.string/string.cons/substr.pass.cpp
@@ -98,7 +98,6 @@
 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())
     {
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp
@@ -87,7 +87,6 @@
 
 void test_with_inner_alloc()
 {
-    using VoidAlloc1 = CountingAllocator<void, 1>;
     using VoidAlloc2 = CountingAllocator<void, 2>;
 
     AllocController POuter;
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp
@@ -88,7 +88,6 @@
 
 void test_with_inner_alloc()
 {
-    using VoidAlloc1 = CountingAllocator<void, 1>;
     using VoidAlloc2 = CountingAllocator<void, 2>;
 
     AllocController POuter;
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp
@@ -87,7 +87,6 @@
 
 void test_with_inner_alloc()
 {
-    using VoidAlloc1 = CountingAllocator<void, 1>;
     using VoidAlloc2 = CountingAllocator<void, 2>;
 
     AllocController POuter;
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp
@@ -83,7 +83,6 @@
 
 void test_with_inner_alloc()
 {
-    using VoidAlloc1 = CountingAllocator<void, 1>;
     using VoidAlloc2 = CountingAllocator<void, 2>;
 
     AllocController POuter;
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp
@@ -31,7 +31,6 @@
 //   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;
@@ -41,7 +40,6 @@
         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));
@@ -66,7 +64,6 @@
 // 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;
@@ -76,7 +73,6 @@
         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));
@@ -101,7 +97,6 @@
 // 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;
@@ -111,7 +106,6 @@
         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));
Index: test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp
@@ -61,11 +61,9 @@
 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), "");
     }
     {
@@ -97,18 +95,15 @@
 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));