[libc++] Remove the names of unreferenced parameters.

[STL_MSFT]

Summary

[libc++] Remove the names of unreferenced parameters.

Fixes MSVC "warning C4100: unreferenced formal parameter".

[EricWF]

r267852.

test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp

 //  Complexity: At most (3/2) * t.size() applications of the corresponding predicate.
 
 #include <algorithm>
 #include <functional>
 #include <cassert>
 
 #include "counting_predicates.hpp"
 
-bool all_equal(int a, int b) { return false; } // everything is equal
+bool all_equal(int, int) { return false; } // everything is equal
 
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 void test_all_equal(std::initializer_list<int> il)
 {
     binary_counting_predicate<bool(*)(int, int), int, int> pred (all_equal);
     std::pair<int, int> p = std::minmax(il, std::ref(pred));
     const int *ptr = il.end();
     assert(p.first == *il.begin());

test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp

for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i, ++first)
         assert(*i == *first);
 }
 
 #if __cplusplus >= 201103L
 
 template <class T>
 struct implicit_conv_allocator : min_allocator<T>
 {
-    implicit_conv_allocator(void* p) {}
+    implicit_conv_allocator(void*) {}
     implicit_conv_allocator(const implicit_conv_allocator&) = default;
 };
 
 #endif
 
 int main()
 {
     {

test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/custom_alloc.pass.cpp

 
 // strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*));
 
 #include <strstream>
 #include <cassert>
 
 int called = 0;
 
-void* my_alloc(std::size_t n)
+void* my_alloc(std::size_t)
 {
     static char buf[10000];
     ++called;
     return buf;
 }
 
 void my_free(void*)
 {

test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/default_ctor.pass.cpp

 #if _LIBCPP_STD_VER > 11
 
 class test1
     : public std::error_category
 {
 public:
     constexpr test1() = default;  // won't compile if error_category() is not constexpr
     virtual const char* name() const noexcept {return nullptr;}
-    virtual std::string message(int ev) const {return std::string();}
+    virtual std::string message(int) const {return std::string();}
 };
 
 #endif  // _LIBCPP_STD_VER > 11
 
 int main()
 {
 #if _LIBCPP_STD_VER > 11
     static_assert(std::is_nothrow_default_constructible<test1>::value,
                                  "error_category() must exist and be noexcept");
 #endif  // _LIBCPP_STD_VER > 11
 }

test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg_off.pass.cpp

testbuf(const string_type& str)
                    const_cast<CharT*>(str_.data()) + str_.size());
     }
 
     CharT* eback() const {return base::eback();}
     CharT* gptr() const {return base::gptr();}
     CharT* egptr() const {return base::egptr();}
 protected:
     typename base::pos_type seekoff(typename base::off_type off,
-                                    std::ios_base::seekdir way,
+                                    std::ios_base::seekdir,
                                     std::ios_base::openmode which)
     {
         assert(which == std::ios_base::in);
         ++seekoff_called;
         return off;
     }
 };
 

test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetn.pass.cpp

 int xsgetn_called = 0;
 
 struct test
     : public std::basic_streambuf<char>
 {
     test() {}
 
 protected:
-    std::streamsize xsgetn(char_type* s, std::streamsize n)
+    std::streamsize xsgetn(char_type*, std::streamsize)
     {
         ++xsgetn_called;
         return 10;
     }
 };
 
 int main()
 {
     test t;
     assert(xsgetn_called == 0);
     assert(t.sgetn(0, 0) == 10);
     assert(xsgetn_called == 1);
 }

test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sputbackc.pass.cpp

struct test
     test() {}
 
     void setg(char* gbeg, char* gnext, char* gend)
     {
         base::setg(gbeg, gnext, gend);
     }
 
 protected:
-    int_type pbackfail(int_type c = traits_type::eof())
+    int_type pbackfail(int_type = traits_type::eof())
     {
         ++pbackfail_called;
         return 'a';
     }
 };
 
 int main()
 {

test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sungetc.pass.cpp

struct test
     test() {}
 
     void setg(char* gbeg, char* gnext, char* gend)
     {
         base::setg(gbeg, gnext, gend);
     }
 
 protected:
-    int_type pbackfail(int_type c = traits_type::eof())
+    int_type pbackfail(int_type = traits_type::eof())
     {
         ++pbackfail_called;
         return 'a';
     }
 };
 
 int main()
 {

test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputc.pass.cpp

void setg(char* gbeg, char* gnext, char* gend)
         base::setg(gbeg, gnext, gend);
     }
     void setp(char* pbeg, char* pend)
     {
         base::setp(pbeg, pend);
     }
 
 protected:
-    int_type overflow(int_type c = traits_type::eof())
+    int_type overflow(int_type = traits_type::eof())
     {
         ++overflow_called;
         return 'a';
     }
 };
 
 int main()
 {

test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputn.pass.cpp

 int xsputn_called = 0;
 
 struct test
     : public std::basic_streambuf<char>
 {
     test() {}
 
 protected:
-    std::streamsize xsputn(const char_type* s, std::streamsize n)
+    std::streamsize xsputn(const char_type*, std::streamsize)
     {
         ++xsputn_called;
         return 5;
     }
 };
 
 int main()
 {
     test t;
     assert(xsputn_called == 0);
     assert(t.sputn(0, 0) == 5);
     assert(xsputn_called == 1);
 }

test/std/utilities/function.objects/bind/func.bind/func.bind.bind/PR23141_invoke_not_constexpr.pass.cpp

 
 // https://llvm.org/bugs/show_bug.cgi?id=23141
 #include <functional>
 #include <type_traits>
 
 struct Fun
 {
   template<typename T, typename U>
-  void operator()(T && t, U && u) const
+  void operator()(T &&, U &&) const
   {
     static_assert(std::is_same<U, int &>::value, "");
   }
 };
 
 int main()
 {
     std::bind(Fun{}, std::placeholders::_1, 42)("hello");
 }

test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp

 
 // http://llvm.org/bugs/show_bug.cgi?id=22003
 
 #include <functional>
 
 struct DummyUnaryFunction
 {
     template <typename S>
-    int operator()(S const & s) const { return 0; }
+    int operator()(S const &) const { return 0; }
 };
 
 struct BadUnaryFunction
 {
     template <typename S>
     constexpr int operator()(S const & s) const
     {
         // Trigger a compile error if this function is instantiated.
         // The constexpr is needed so that it is instantiated while checking
         // __invoke_of<BadUnaryFunction &, ...>.
         static_assert(!std::is_same<S, S>::value, "Shit");
         return 0;
     }
 };
 
-int main(int argc, char* argv[])
+int main()
 {
     // Check that BadUnaryFunction::operator()(S const &) is not
     // instantiated when checking if BadUnaryFunction is a nested bind
     // expression during b(0). See PR22003.
     auto b = std::bind(DummyUnaryFunction(), BadUnaryFunction());
     b(0);
     auto b2 = std::bind<long>(DummyUnaryFunction(), BadUnaryFunction());
     b2(0);
 }

test/std/utilities/intseq/intseq.general/integer_seq.pass.cpp

 #include <tuple>
 #include <utility>
 #include <type_traits>
 #include <cassert>
 
 #if _LIBCPP_STD_VER > 11
 
 template <typename AtContainer, typename T, T... I>
-auto extract ( const AtContainer &t, const std::integer_sequence<T, I...> idx )
+auto extract ( const AtContainer &t, const std::integer_sequence<T, I...> )
 -> decltype ( std::make_tuple ( std::get<I>(t)... ))
 {     return  std::make_tuple ( std::get<I>(t)... ); }
 
 #endif  // _LIBCPP_STD_VER > 11
 
 int main()
 {
 #if _LIBCPP_STD_VER > 11

test/std/utilities/tuple/tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp

 // UNSUPPORTED: c++98, c++03
 
 #include <tuple>
 #include <type_traits>
 #include <cassert>
 
 template <class Tuple>
 void
-test0(const Tuple& t)
+test0(const Tuple&)
 {
     static_assert(std::tuple_size<Tuple>::value == 0, "");
 }
 
 template <class Tuple>
 void
 test1a(const Tuple& t)
 {
test2a(const Tuple& t)
     static_assert(std::is_same<typename std::tuple_element<1, Tuple>::type, char&>::value, "");
     assert(std::get<0>(t) == 2.5);
     assert(std::get<1>(t) == 'a');
 }
 
 #if _LIBCPP_STD_VER > 11
 template <class Tuple>
 constexpr int 
-test3(const Tuple& t)
+test3(const Tuple&)
 {
     return std::tuple_size<Tuple>::value;
 }
 #endif
 
 int main()
 {
     {

test/support/allocators.h

public:
     static bool move_called;
     static bool allocate_called;
 
     A2(const A2& a) TEST_NOEXCEPT : id_(a.id()) {copy_called = true;}
     A2(A2&& a)      TEST_NOEXCEPT : id_(a.id()) {move_called = true;}
     A2& operator=(const A2& a) TEST_NOEXCEPT { id_ = a.id(); copy_called = true; return *this;}
     A2& operator=(A2&& a)      TEST_NOEXCEPT { id_ = a.id(); move_called = true; return *this;}
 
-    T* allocate(std::size_t n, const void* hint)
+    T* allocate(std::size_t, const void* hint)
     {
         allocate_called = true;
         return (T*)hint;
     }
 };
 
 template <class T> bool A2<T>::copy_called = false;
 template <class T> bool A2<T>::move_called = false;

test/support/test_allocator.h

 #else
                 std::terminate();
 #endif
             }
             ++time_to_throw;
             ++alloc_count;
             return (pointer)::operator new(n * sizeof(T));
         }
-    void deallocate(pointer p, size_type n)
+    void deallocate(pointer p, size_type)
         {assert(data_ >= 0); --alloc_count; ::operator delete((void*)p);}
     size_type max_size() const throw()
         {return UINT_MAX / sizeof(T);}
     void construct(pointer p, const T& val)
         {::new(p) T(val);}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     void construct(pointer p, T&& val)
         {::new(p) T(std::move(val));}

 #else
                 std::terminate();
 #endif
             }
             ++time_to_throw;
             ++alloc_count;
             return (pointer)::operator new (n * sizeof(T));
         }
-    void deallocate(pointer p, size_type n)
+    void deallocate(pointer p, size_type)
         {assert(data_ >= 0); --alloc_count; ::operator delete((void*)p); }
     size_type max_size() const throw()
         {return UINT_MAX / sizeof(T);}
     void construct(pointer p, const T& val)
         {::new(p) T(val);}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     void construct(pointer p, T&& val)
         {::new(p) T(std::move(val));}
public:
     typedef T value_type;
 
     other_allocator() : data_(-1) {}
     explicit other_allocator(int i) : data_(i) {}
     template <class U> other_allocator(const other_allocator<U>& a)
         : data_(a.data_) {}
     T* allocate(std::size_t n)
         {return (T*)::operator new(n * sizeof(T));}
-    void deallocate(T* p, std::size_t n)
+    void deallocate(T* p, std::size_t)
         {::operator delete((void*)p);}
 
     other_allocator select_on_container_copy_construction() const
         {return other_allocator(-2);}
 
     friend bool operator==(const other_allocator& x, const other_allocator& y)
         {return x.data_ == y.data_;}
     friend bool operator!=(const other_allocator& x, const other_allocator& y)