Merge bitcoin#8808: Do not shadow variables (gcc set)

laanwj · PastaPastaPasta · commit 3d3443b6a9a9 · 2019-02-01T00:41:12.000-06:00
ad1ae7a Check and enable -Wshadow by default. (Pavel Janík) 9de90bb Do not shadow variables (gcc set) (Pavel Janík) Tree-SHA512: 9517feb423dc8ddd63896016b25324673bfbe0bffa97f22996f59d7a3fcbdc2ebf2e43ac02bc067546f54e293e9b2f2514be145f867321e9031f895c063d9fb8
diff --git a/configure.ac b/configure.ac
@@ -227,6 +227,7 @@ if test "x$CXXFLAGS_overridden" = "xno"; then
   AX_CHECK_COMPILE_FLAG([-Wformat],[CXXFLAGS="$CXXFLAGS -Wformat"],,[[$CXXFLAG_WERROR]])
   AX_CHECK_COMPILE_FLAG([-Wvla],[CXXFLAGS="$CXXFLAGS -Wvla"],,[[$CXXFLAG_WERROR]])
   AX_CHECK_COMPILE_FLAG([-Wformat-security],[CXXFLAGS="$CXXFLAGS -Wformat-security"],,[[$CXXFLAG_WERROR]])
+  AX_CHECK_COMPILE_FLAG([-Wshadow],[CXXFLAGS="$CXXFLAGS -Wshadow"],,[[$CXXFLAG_WERROR]])
 
   ## Some compilers (gcc) ignore unknown -Wno-* options, but warn about all
   ## unknown options if any other warning is produced. Test the -Wfoo case, and
diff --git a/src/arith_uint256.cpp b/src/arith_uint256.cpp
@@ -173,9 +173,9 @@ unsigned int base_uint<BITS>::bits() const
 {
     for (int pos = WIDTH - 1; pos >= 0; pos--) {
         if (pn[pos]) {
-            for (int bits = 31; bits > 0; bits--) {
-                if (pn[pos] & 1 << bits)
-                    return 32 * pos + bits + 1;
+            for (int nbits = 31; nbits > 0; nbits--) {
+                if (pn[pos] & 1 << nbits)
+                    return 32 * pos + nbits + 1;
             }
             return 32 * pos + 1;
         }
diff --git a/src/bench/lockedpool.cpp b/src/bench/lockedpool.cpp
@@ -13,7 +13,7 @@
 #define BITER 5000
 #define MSIZE 2048
 
-static void LockedPool(benchmark::State& state)
+static void BenchLockedPool(benchmark::State& state)
 {
     void *synth_base = reinterpret_cast<void*>(0x08000000);
     const size_t synth_size = 1024*1024;
@@ -43,5 +43,5 @@ static void LockedPool(benchmark::State& state)
     addr.clear();
 }
 
-BENCHMARK(LockedPool);
+BENCHMARK(BenchLockedPool);
 
diff --git a/src/chain.h b/src/chain.h
@@ -382,9 +382,9 @@ class CDiskBlockIndex : public CBlockIndex
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream& s, Operation ser_action) {
-        int nVersion = s.GetVersion();
+        int _nVersion = s.GetVersion();
         if (!(s.GetType() & SER_GETHASH))
-            READWRITE(VARINT(nVersion));
+            READWRITE(VARINT(_nVersion));
 
         READWRITE(VARINT(nHeight));
         READWRITE(VARINT(nStatus));
diff --git a/src/script/script.cpp b/src/script/script.cpp
@@ -183,18 +183,18 @@ unsigned int CScript::GetSigOpCount(const CScript& scriptSig) const
     // get the last item that the scriptSig
     // pushes onto the stack:
     const_iterator pc = scriptSig.begin();
-    std::vector<unsigned char> data;
+    std::vector<unsigned char> vData;
     while (pc < scriptSig.end())
     {
         opcodetype opcode;
-        if (!scriptSig.GetOp(pc, opcode, data))
+        if (!scriptSig.GetOp(pc, opcode, vData))
             return 0;
         if (opcode > OP_16)
             return 0;
     }
 
     /// ... and return its opcount:
-    CScript subscript(data.begin(), data.end());
+    CScript subscript(vData.begin(), vData.end());
     return subscript.GetSigOpCount(true);
 }
 
diff --git a/src/script/script.h b/src/script/script.h
@@ -448,16 +448,16 @@ class CScript : public CScriptBase
         else if (b.size() <= 0xffff)
         {
             insert(end(), OP_PUSHDATA2);
-            uint8_t data[2];
-            WriteLE16(data, b.size());
-            insert(end(), data, data + sizeof(data));
+            uint8_t _data[2];
+            WriteLE16(_data, b.size());
+            insert(end(), _data, _data + sizeof(_data));
         }
         else
         {
             insert(end(), OP_PUSHDATA4);
-            uint8_t data[4];
-            WriteLE32(data, b.size());
-            insert(end(), data, data + sizeof(data));
+            uint8_t _data[4];
+            WriteLE32(_data, b.size());
+            insert(end(), _data, _data + sizeof(_data));
         }
         insert(end(), b.begin(), b.end());
         return *this;
diff --git a/src/streams.h b/src/streams.h
@@ -545,11 +545,11 @@ class CBufferedFile
             readNow = nAvail;
         if (readNow == 0)
             return false;
-        size_t read = fread((void*)&vchBuf[pos], 1, readNow, src);
-        if (read == 0) {
+        size_t nBytes = fread((void*)&vchBuf[pos], 1, readNow, src);
+        if (nBytes == 0) {
             throw std::ios_base::failure(feof(src) ? "CBufferedFile::Fill: end of file" : "CBufferedFile::Fill: fread failed");
         } else {
-            nSrcPos += read;
+            nSrcPos += nBytes;
             return true;
         }
     }
diff --git a/src/support/lockedpool.cpp b/src/support/lockedpool.cpp
@@ -357,8 +357,8 @@ LockedPool::LockedPageArena::~LockedPageArena()
 /*******************************************************************************/
 // Implementation: LockedPoolManager
 //
-LockedPoolManager::LockedPoolManager(std::unique_ptr<LockedPageAllocator> allocator):
-    LockedPool(std::move(allocator), &LockedPoolManager::LockingFailed)
+LockedPoolManager::LockedPoolManager(std::unique_ptr<LockedPageAllocator> allocator_in):
+    LockedPool(std::move(allocator_in), &LockedPoolManager::LockingFailed)
 {
 }
 
diff --git a/src/test/coins_tests.cpp b/src/test/coins_tests.cpp
@@ -75,7 +75,7 @@ class CCoinsViewTest : public CCoinsView
 class CCoinsViewCacheTest : public CCoinsViewCache
 {
 public:
-    CCoinsViewCacheTest(CCoinsView* base) : CCoinsViewCache(base) {}
+    CCoinsViewCacheTest(CCoinsView* _base) : CCoinsViewCache(_base) {}
 
     void SelfTest() const
     {
diff --git a/src/timedata.h b/src/timedata.h
@@ -27,9 +27,9 @@ class CMedianFilter
     unsigned int nSize;
 
 public:
-    CMedianFilter(unsigned int size, T initial_value) : nSize(size)
+    CMedianFilter(unsigned int _size, T initial_value) : nSize(_size)
     {
-        vValues.reserve(size);
+        vValues.reserve(_size);
         vValues.push_back(initial_value);
         vSorted = vValues;
     }
@@ -48,14 +48,14 @@ class CMedianFilter
 
     T median() const
     {
-        int size = vSorted.size();
-        assert(size > 0);
-        if (size & 1) // Odd number of elements
+        int vSortedSize = vSorted.size();
+        assert(vSortedSize > 0);
+        if (vSortedSize & 1) // Odd number of elements
         {
-            return vSorted[size / 2];
+            return vSorted[vSortedSize / 2];
         } else // Even number of elements
         {
-            return (vSorted[size / 2 - 1] + vSorted[size / 2]) / 2;
+            return (vSorted[vSortedSize / 2 - 1] + vSorted[vSortedSize / 2]) / 2;
         }
     }
 
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
@@ -441,17 +441,17 @@ bool CWallet::Unlock(const SecureString& strWalletPassphrase, bool fForMixingOnl
     }
 
     CCrypter crypter;
-    CKeyingMaterial vMasterKey;
+    CKeyingMaterial _vMasterKey;
 
     {
         LOCK(cs_wallet);
         BOOST_FOREACH(const MasterKeyMap::value_type& pMasterKey, mapMasterKeys)
         {
             if (!crypter.SetKeyFromPassphrase(strWalletPassphraseFinal, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
                 return false;
-            if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, vMasterKey))
+            if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, _vMasterKey))
                 continue; // try another master key
-            if (CCryptoKeyStore::Unlock(vMasterKey, fForMixingOnly)) {
+            if (CCryptoKeyStore::Unlock(_vMasterKey, fForMixingOnly)) {
                 if(nWalletBackups == -2) {
                     TopUpKeyPool();
                     LogPrintf("Keypool replenished, re-initializing automatic backups.\n");
@@ -489,14 +489,14 @@ bool CWallet::ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase,
         Lock();
 
         CCrypter crypter;
-        CKeyingMaterial vMasterKey;
+        CKeyingMaterial _vMasterKey;
         BOOST_FOREACH(MasterKeyMap::value_type& pMasterKey, mapMasterKeys)
         {
             if(!crypter.SetKeyFromPassphrase(strOldWalletPassphraseFinal, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
                 return false;
-            if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, vMasterKey))
+            if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, _vMasterKey))
                 return false;
-            if (CCryptoKeyStore::Unlock(vMasterKey))
+            if (CCryptoKeyStore::Unlock(_vMasterKey))
             {
                 int64_t nStartTime = GetTimeMillis();
                 crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod);
@@ -513,7 +513,7 @@ bool CWallet::ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase,
 
                 if (!crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
                     return false;
-                if (!crypter.Encrypt(vMasterKey, pMasterKey.second.vchCryptedKey))
+                if (!crypter.Encrypt(_vMasterKey, pMasterKey.second.vchCryptedKey))
                     return false;
                 CWalletDB(strWalletFile).WriteMasterKey(pMasterKey.first, pMasterKey.second);
                 if (fWasLocked)
@@ -757,10 +757,10 @@ bool CWallet::EncryptWallet(const SecureString& strWalletPassphrase)
     if (IsCrypted())
         return false;
 
-    CKeyingMaterial vMasterKey;
+    CKeyingMaterial _vMasterKey;
 
-    vMasterKey.resize(WALLET_CRYPTO_KEY_SIZE);
-    GetStrongRandBytes(&vMasterKey[0], WALLET_CRYPTO_KEY_SIZE);
+    _vMasterKey.resize(WALLET_CRYPTO_KEY_SIZE);
+    GetStrongRandBytes(&_vMasterKey[0], WALLET_CRYPTO_KEY_SIZE);
 
     CMasterKey kMasterKey;
 
@@ -783,7 +783,7 @@ bool CWallet::EncryptWallet(const SecureString& strWalletPassphrase)
 
     if (!crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, kMasterKey.nDeriveIterations, kMasterKey.nDerivationMethod))
         return false;
-    if (!crypter.Encrypt(vMasterKey, kMasterKey.vchCryptedKey))
+    if (!crypter.Encrypt(_vMasterKey, kMasterKey.vchCryptedKey))
         return false;
 
     {
@@ -805,7 +805,7 @@ bool CWallet::EncryptWallet(const SecureString& strWalletPassphrase)
         CHDChain hdChainCurrent;
         GetHDChain(hdChainCurrent);
 
-        if (!EncryptKeys(vMasterKey))
+        if (!EncryptKeys(_vMasterKey))
         {
             if (fFileBacked) {
                 pwalletdbEncryption->TxnAbort();
@@ -817,7 +817,7 @@ bool CWallet::EncryptWallet(const SecureString& strWalletPassphrase)
         }
 
         if (!hdChainCurrent.IsNull()) {
-            assert(EncryptHDChain(vMasterKey));
+            assert(EncryptHDChain(_vMasterKey));
 
             CHDChain hdChainCrypted;
             assert(GetHDChain(hdChainCrypted));
diff --git a/src/wallet/walletdb.h b/src/wallet/walletdb.h
@@ -77,7 +77,7 @@ class CKeyMetadata
 class CWalletDB : public CDB
 {
 public:
-    CWalletDB(const std::string& strFilename, const char* pszMode = "r+", bool fFlushOnClose = true) : CDB(strFilename, pszMode, fFlushOnClose)
+    CWalletDB(const std::string& strFilename, const char* pszMode = "r+", bool _fFlushOnClose = true) : CDB(strFilename, pszMode, _fFlushOnClose)
     {
     }
 

Original file line number	Diff line number	Diff line change
`@@ -173,9 +173,9 @@ unsigned int base_uint<BITS>::bits() const`
`173`	`173`	`{`
`174`	`174`	`for (int pos = WIDTH - 1; pos >= 0; pos--) {`
`175`	`175`	`if (pn[pos]) {`
`176`		`- for (int bits = 31; bits > 0; bits--) {`
`177`		`- if (pn[pos] & 1 << bits)`
`178`		`- return 32 * pos + bits + 1;`
	`176`	`+ for (int nbits = 31; nbits > 0; nbits--) {`
	`177`	`+ if (pn[pos] & 1 << nbits)`
	`178`	`+ return 32 * pos + nbits + 1;`
`179`	`179`	`}`
`180`	`180`	`return 32 * pos + 1;`
`181`	`181`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@`
`13`	`13`	`#define BITER 5000`
`14`	`14`	`#define MSIZE 2048`
`15`	`15`
`16`		`-static void LockedPool(benchmark::State& state)`
	`16`	`+static void BenchLockedPool(benchmark::State& state)`
`17`	`17`	`{`
`18`	`18`	`void synth_base = reinterpret_cast<void>(0x08000000);`
`19`	`19`	`const size_t synth_size = 1024*1024;`
`@@ -43,5 +43,5 @@ static void LockedPool(benchmark::State& state)`
`43`	`43`	`addr.clear();`
`44`	`44`	`}`
`45`	`45`
`46`		`-BENCHMARK(LockedPool);`
	`46`	`+BENCHMARK(BenchLockedPool);`
`47`	`47`
Original file line number	Diff line number	Diff line change
`@@ -448,16 +448,16 @@ class CScript : public CScriptBase`
`448`	`448`	`else if (b.size() <= 0xffff)`
`449`	`449`	`{`
`450`	`450`	`insert(end(), OP_PUSHDATA2);`
`451`		`- uint8_t data[2];`
`452`		`- WriteLE16(data, b.size());`
`453`		`- insert(end(), data, data + sizeof(data));`
	`451`	`+ uint8_t _data[2];`
	`452`	`+ WriteLE16(_data, b.size());`
	`453`	`+ insert(end(), _data, _data + sizeof(_data));`
`454`	`454`	`}`
`455`	`455`	`else`
`456`	`456`	`{`
`457`	`457`	`insert(end(), OP_PUSHDATA4);`
`458`		`- uint8_t data[4];`
`459`		`- WriteLE32(data, b.size());`
`460`		`- insert(end(), data, data + sizeof(data));`
	`458`	`+ uint8_t _data[4];`
	`459`	`+ WriteLE32(_data, b.size());`
	`460`	`+ insert(end(), _data, _data + sizeof(_data));`
`461`	`461`	`}`
`462`	`462`	`insert(end(), b.begin(), b.end());`
`463`	`463`	`return *this;`
Original file line number	Diff line number	Diff line change
`@@ -357,8 +357,8 @@ LockedPool::LockedPageArena::~LockedPageArena()`
`357`	`357`	`/*******************************************************************************/`
`358`	`358`	`// Implementation: LockedPoolManager`
`359`	`359`	`//`
`360`		`-LockedPoolManager::LockedPoolManager(std::unique_ptr<LockedPageAllocator> allocator):`
`361`		`- LockedPool(std::move(allocator), &LockedPoolManager::LockingFailed)`
	`360`	`+LockedPoolManager::LockedPoolManager(std::unique_ptr<LockedPageAllocator> allocator_in):`
	`361`	`+ LockedPool(std::move(allocator_in), &LockedPoolManager::LockingFailed)`
`362`	`362`	`{`
`363`	`363`	`}`
`364`	`364`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ class CCoinsViewTest : public CCoinsView`
`75`	`75`	`class CCoinsViewCacheTest : public CCoinsViewCache`
`76`	`76`	`{`
`77`	`77`	`public:`
`78`		`- CCoinsViewCacheTest(CCoinsView* base) : CCoinsViewCache(base) {}`
	`78`	`+ CCoinsViewCacheTest(CCoinsView* _base) : CCoinsViewCache(_base) {}`
`79`	`79`
`80`	`80`	`void SelfTest() const`
`81`	`81`	`{`
Original file line number	Diff line number	Diff line change
`@@ -27,9 +27,9 @@ class CMedianFilter`
`27`	`27`	`unsigned int nSize;`
`28`	`28`
`29`	`29`	`public:`
`30`		`- CMedianFilter(unsigned int size, T initial_value) : nSize(size)`
	`30`	`+ CMedianFilter(unsigned int _size, T initial_value) : nSize(_size)`
`31`	`31`	`{`
`32`		`- vValues.reserve(size);`
	`32`	`+ vValues.reserve(_size);`
`33`	`33`	`vValues.push_back(initial_value);`
`34`	`34`	`vSorted = vValues;`
`35`	`35`	`}`
`@@ -48,14 +48,14 @@ class CMedianFilter`
`48`	`48`
`49`	`49`	`T median() const`
`50`	`50`	`{`
`51`		`- int size = vSorted.size();`
`52`		`- assert(size > 0);`
`53`		`- if (size & 1) // Odd number of elements`
	`51`	`+ int vSortedSize = vSorted.size();`
	`52`	`+ assert(vSortedSize > 0);`
	`53`	`+ if (vSortedSize & 1) // Odd number of elements`
`54`	`54`	`{`
`55`		`- return vSorted[size / 2];`
	`55`	`+ return vSorted[vSortedSize / 2];`
`56`	`56`	`} else // Even number of elements`
`57`	`57`	`{`
`58`		`- return (vSorted[size / 2 - 1] + vSorted[size / 2]) / 2;`
	`58`	`+ return (vSorted[vSortedSize / 2 - 1] + vSorted[vSortedSize / 2]) / 2;`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ class CKeyMetadata`
`77`	`77`	`class CWalletDB : public CDB`
`78`	`78`	`{`
`79`	`79`	`public:`
`80`		`- CWalletDB(const std::string& strFilename, const char* pszMode = "r+", bool fFlushOnClose = true) : CDB(strFilename, pszMode, fFlushOnClose)`
	`80`	`+ CWalletDB(const std::string& strFilename, const char* pszMode = "r+", bool _fFlushOnClose = true) : CDB(strFilename, pszMode, _fFlushOnClose)`
`81`	`81`	`{`
`82`	`82`	`}`
`83`	`83`