Fix some `-Wshadow` diagnostics emitted by Clang trunk

[• Quuxplusone]

Summary

This is what I see when building make -j5 check-cxx with Clang trunk (built from source) on OS X.

In file included from /llvm/projects/libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.space/space.pass.cpp:22:
/llvm/projects/libcxx/test/support/filesystem_test_helper.hpp:455:62: error: declaration shadows a field of 'ExceptionChecker' [-Werror,-Wshadow]
  explicit ExceptionChecker(std::errc first_err, const char* func_name,
                                                             ^
/llvm/projects/libcxx/test/support/filesystem_test_helper.hpp:452:15: note: previous declaration is here
  const char* func_name;
              ^

In file included from /llvm/projects/libcxx/test/std/language.support/support.limits/support.limits.general/charconv.pass.cpp:17:
/llvm/projects/libcxx/include/charconv:473:35: error: declaration shadows a local variable [-Werror,-Wshadow]
    auto __find_non_zero = [](_It __first, _It __last) {
                                  ^
/llvm/projects/libcxx/include/charconv:470:30: note: previous declaration is here
__subject_seq_combinator(_It __first, _It __last, _Tp& __value, _Fn __f,
                             ^

The -Werror,-Wshadow seems to be coming from here. I don't know why non-Apple platforms don't see these same warnings.

$ git grep Wshadow utils/libcxx/
utils/libcxx/test/config.py:        self.cxx.addWarningFlagIfSupported('-Wshadow')

[ldionne]

I'm not sure these warnings normally hit users because they should include us with -isystem, right?

include/charconv

549

In this case, would it be less intrusive to rename the parameter from __first to __first_it or something like that? I think the parameters are used less often here.

[• Quuxplusone]

include/charconv

549

That sounds good for __first and __last, but what about __value and __base?

[• Quuxplusone]

This is what I see when building make -j5 check-cxx with Clang trunk (built from source) on OS X.

I discovered yesterday that make check-cxx actually uses the system compiler by default, so therefore I had not been using Clang trunk; I had been using

$ clang --version
Apple LLVM version 7.3.0 (clang-703.0.31)
Target: x86_64-apple-darwin15.6.0
Thread model: posix
InstalledDir: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin

With Clang trunk, I don't see -Wshadow warnings after all.

include/charconv

else
         return {'A' <= __c && __c < 'A' + __base - 10, __c - 'A' + 10};
 }
 
 template <typename _It, typename _Tp, typename _Fn, typename... _Ts>
 inline _LIBCPP_INLINE_VISIBILITY from_chars_result
 __subject_seq_combinator(_It __first, _It __last, _Tp& __value, _Fn __f,
                          _Ts... __args)
 {
-    auto __find_non_zero = [](_It __first, _It __last) {
-        for (; __first != __last; ++__first)
-            if (*__first != '0')
+    auto __find_non_zero = [](_It __firstx, _It __lastx) {
+        for (; __firstx != __lastx; ++__firstx)
+            if (*__firstx != '0')
                 break;
-        return __first;
+        return __firstx;
     };
 
     auto __p = __find_non_zero(__first, __last);
     if (__p == __last || !__in_pattern(*__p, __args...))
     {
         if (__p == __first)
             return {__first, errc::invalid_argument};
         else

 inline _LIBCPP_INLINE_VISIBILITY from_chars_result
 __from_chars_atoi(const char* __first, const char* __last, _Tp& __value)
 {
     using __tx = __itoa::__traits<_Tp>;
     using __output_type = typename __tx::type;
 
     return __subject_seq_combinator(
         __first, __last, __value,
-        [](const char* __first, const char* __last,
-           _Tp& __value) -> from_chars_result {
+        [](const char* __firstx, const char* __lastx,
+           _Tp& __valuex) -> from_chars_result {
             __output_type __a, __b;
-            auto __p = __tx::__read(__first, __last, __a, __b);
-            if (__p == __last || !__in_pattern(*__p))
+            auto __p = __tx::__read(__firstx, __lastx, __a, __b);
+            if (__p == __lastx || !__in_pattern(*__p))
             {
                 __output_type __m = (numeric_limits<_Tp>::max)();
                 if (__m >= __a && __m - __a >= __b)
                 {
-                    __value = __a + __b;
+                    __valuex = __a + __b;
                     return {__p, {}};
                 }
             }
             return {__p, errc::result_out_of_range};
         });
 }
 
 template <typename _Tp, enable_if_t<is_signed<_Tp>::value, int> = 0>

 __from_chars_integral(const char* __first, const char* __last, _Tp& __value,
                       int __base)
 {
     if (__base == 10)
         return __from_chars_atoi(__first, __last, __value);
 
     return __subject_seq_combinator(
         __first, __last, __value,
-        [](const char* __p, const char* __last, _Tp& __value,
-           int __base) -> from_chars_result {
+        [](const char* __p, const char* __lastx, _Tp& __valuex,
+           int __basex) -> from_chars_result {
             using __tl = numeric_limits<_Tp>;
-            auto __digits = __tl::digits / log2f(float(__base));
-            _Tp __a = __in_pattern(*__p++, __base).__val, __b = 0;
+            auto __digits = __tl::digits / log2f(float(__basex));
+            _Tp __a = __in_pattern(*__p++, __basex).__val, __b = 0;
 
-            for (int __i = 1; __p != __last; ++__i, ++__p)
+            for (int __i = 1; __p != __lastx; ++__i, ++__p)
             {
-                if (auto __c = __in_pattern(*__p, __base))
+                if (auto __c = __in_pattern(*__p, __basex))
                 {
                     if (__i < __digits - 1)
-                        __a = __a * __base + __c.__val;
+                        __a = __a * __basex + __c.__val;
                     else
                     {
-                        if (!__itoa::__mul_overflowed(__a, __base, __a))
+                        if (!__itoa::__mul_overflowed(__a, __basex, __a))
                             ++__p;
                         __b = __c.__val;
                         break;
                     }
                 }
                 else
                     break;
             }
 
-            if (__p == __last || !__in_pattern(*__p, __base))
+            if (__p == __lastx || !__in_pattern(*__p, __basex))
             {
                 if ((__tl::max)() - __a >= __b)
                 {
-                    __value = __a + __b;
+                    __valuex = __a + __b;
                     return {__p, {}};
                 }
             }
             return {__p, errc::result_out_of_range};
         },
         __base);
 }
 

test/support/filesystem_test_helper.hpp

 struct ExceptionChecker {
   std::errc expected_err;
   fs::path expected_path1;
   fs::path expected_path2;
   unsigned num_paths;
   const char* func_name;
   std::string opt_message;
 
-  explicit ExceptionChecker(std::errc first_err, const char* func_name,
+  explicit ExceptionChecker(std::errc first_err, const char* pfunc_name,
                             std::string opt_msg = {})
-      : expected_err{first_err}, num_paths(0), func_name(func_name),
+      : expected_err{first_err}, num_paths(0), func_name(pfunc_name),
         opt_message(opt_msg) {}
   explicit ExceptionChecker(fs::path p, std::errc first_err,
-                            const char* func_name, std::string opt_msg = {})
+                            const char* pfunc_name, std::string opt_msg = {})
       : expected_err(first_err), expected_path1(p), num_paths(1),
-        func_name(func_name), opt_message(opt_msg) {}
+        func_name(pfunc_name), opt_message(opt_msg) {}
 
   explicit ExceptionChecker(fs::path p1, fs::path p2, std::errc first_err,
-                            const char* func_name, std::string opt_msg = {})
+                            const char* pfunc_name, std::string opt_msg = {})
       : expected_err(first_err), expected_path1(p1), expected_path2(p2),
-        num_paths(2), func_name(func_name), opt_message(opt_msg) {}
+        num_paths(2), func_name(pfunc_name), opt_message(opt_msg) {}
 
   void operator()(fs::filesystem_error const& Err) {
     TEST_CHECK(ErrorIsImp(Err.code(), {expected_err}));
     TEST_CHECK(Err.path1() == expected_path1);
     TEST_CHECK(Err.path2() == expected_path2);
     LIBCPP_ONLY(check_libcxx_string(Err));
   }