Fix some warnings

Signed-off-by: Osyotr <Osyotr@users.noreply.github.com>

Author: Osyotr

generator/generator_tests/descriptions_section_builder_tests.cpp

@@ -231,7 +231,7 @@ class TestDescriptionSectionBuilder
   static int SumPageSizes(std::vector<PageT> const & p)
   {
     return std::accumulate(std::begin(p), std::end(p), 0,
-                           [](int acc, PageT const & p) { return acc + p.second.size(); });
+                           [](int acc, PageT const & p) { return acc + static_cast<int>(p.second.size()); });
   }
 
   static bool CheckLangs(DescriptionsCollectionBuilderStat::LangStatistics const & stat)

libs/base/CMakeLists.txt

@@ -9,7 +9,6 @@ set(SRC
   ../std/windows.hpp
   array_adapters.hpp
   assert.hpp
-  atomic_shared_ptr.hpp
   base.cpp
   base.hpp
   beam.hpp

libs/base/atomic_shared_ptr.hpp

@@ -20,19 +20,19 @@ using namespace std;
 template <template <typename, typename> class Beam>
 void Smoke()
 {
-  size_t const kCapacity = 10;
-  size_t const kTotal = 100;
+  constexpr size_t kCapacity = 10;
+  constexpr size_t kTotal = 100;
 
-  CHECK_LESS_OR_EQUAL(kCapacity, kTotal, ());
+  static_assert(kCapacity <= kTotal);
 
   Beam<uint32_t, double> beam(kCapacity);
 
-  for (uint32_t i = 0; i < kTotal; ++i)
+  for (size_t i = 0; i < kTotal; ++i)
     beam.Add(i, static_cast<double>(i));
 
   vector<double> expected;
   for (size_t i = 0; i < kCapacity; ++i)
-    expected.emplace_back(kTotal - 1 - i);
+    expected.emplace_back(static_cast<double>(kTotal - 1 - i));
 
   vector<double> actual;
   actual.reserve(kCapacity);

libs/base/base_tests/beam_tests.cpp

@@ -35,7 +35,7 @@ void TestWithData(vector<uint32_t> const & lst)
       builder.PushBack(v);
     }
 
-    pair<uint32_t, uint32_t> expected(optCount, lst.size());
+    pair<uint32_t, uint32_t> expected(optCount, static_cast<uint32_t>(lst.size()));
     TEST_EQUAL(builder.GetCount(), expected, ());
   }
 

libs/coding/coding_tests/fixed_bits_ddvector_test.cpp

@@ -35,7 +35,7 @@ DescriptionsCollection Convert(std::vector<RawDescription> const & rawDescriptio
 
     for (auto const & translation : desc.m_strings)
     {
-      ftDesc.m_strIndices.emplace_back(translation.first, descriptions.m_strings.size());
+      ftDesc.m_strIndices.emplace_back(translation.first, static_cast<uint32_t>(descriptions.m_strings.size()));
       descriptions.m_strings.push_back(translation.second);
     }
   }

libs/descriptions/descriptions_tests/descriptions_tests.cpp

@@ -553,7 +553,7 @@ void TriangleFanBatch::BatchData(ref_ptr<GraphicsContext> context, ref_ptr<Attri
           // "(vertexCount + 1) - batchVertexCount" we allocate CPUBuffer on all remaining data
           // + first vertex of fan, that must be duplicate in the next buffer
           // + last vertex of currently uploaded data.
-          cpuBuffers.emplace_back(binding.GetElementSize(), (vertexCount + 2) - batchVertexCount);
+          cpuBuffers.emplace_back(static_cast<uint8_t>(binding.GetElementSize()), (vertexCount + 2) - batchVertexCount);
           CPUBuffer & cpuBuffer = cpuBuffers.back();
           cpuBuffer.UploadData(rawDataPointer, 1);
 

libs/drape/batcher_helpers.cpp

@@ -843,7 +843,7 @@ void GLFunctions::glVertexAttributePointer(int attrLocation, uint32_t count, glC
   ASSERT_EQUAL(CurrentApiVersion, dp::ApiVersion::OpenGLES3, ());
   ASSERT(glVertexAttributePointerFn != nullptr, ());
   GLCHECK(glVertexAttributePointerFn(attrLocation, count, type, convert(needNormalize), stride,
-                                     reinterpret_cast<void *>(offset)));
+                                     reinterpret_cast<GLvoid const *>(static_cast<GLintptr>(offset))));
 }
 
 void GLFunctions::glGetActiveUniform(uint32_t programID, uint32_t uniformIndex, int32_t * uniformSize, glConst * type,
@@ -1048,7 +1048,7 @@ void GLFunctions::glDrawElements(glConst primitive, uint32_t sizeOfIndex, uint32
 {
   ASSERT_EQUAL(CurrentApiVersion, dp::ApiVersion::OpenGLES3, ());
   GLCHECK(::glDrawElements(primitive, indexCount, sizeOfIndex == sizeof(uint32_t) ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT,
-                           reinterpret_cast<GLvoid *>(startIndex * sizeOfIndex)));
+                           reinterpret_cast<GLvoid const *>(static_cast<GLintptr>(startIndex * sizeOfIndex))));
 }
 
 void GLFunctions::glDrawArrays(glConst mode, int32_t first, uint32_t count)

libs/drape/gl_functions.cpp

@@ -21,11 +21,11 @@ using TScriptsArray = std::array<UScriptCode, 32>;
 
 // Writes the script and the script extensions of the Unicode codepoint.
 // Returns the number of written scripts.
-size_t GetScriptExtensions(char32_t codepoint, TScriptsArray & scripts)
+int32_t GetScriptExtensions(char32_t codepoint, TScriptsArray & scripts)
 {
   // Fill scripts with the script extensions.
   UErrorCode icu_error = U_ZERO_ERROR;
-  size_t const count = uscript_getScriptExtensions(static_cast<UChar32>(codepoint), scripts.data(),
+  int32_t const count = uscript_getScriptExtensions(static_cast<UChar32>(codepoint), scripts.data(),
                                                    static_cast<int32_t>(scripts.max_size()), &icu_error);
   if (U_FAILURE(icu_error))
   {
@@ -38,7 +38,7 @@ size_t GetScriptExtensions(char32_t codepoint, TScriptsArray & scripts)
 
 // Intersects the script extensions set of codepoint with scripts and returns the updated size of the scripts.
 // The output result will be a subset of the input result (thus resultSize can only be smaller).
-size_t ScriptSetIntersect(char32_t codepoint, TScriptsArray & inOutScripts, size_t inOutScriptsCount)
+int32_t ScriptSetIntersect(char32_t codepoint, TScriptsArray & inOutScripts, int32_t inOutScriptsCount)
 {
   // Each codepoint has a Script property and a Script Extensions (Scx) property.
   //
@@ -65,7 +65,7 @@ size_t ScriptSetIntersect(char32_t codepoint, TScriptsArray & inOutScripts, size
   // For most of the codepoints, the script extensions set contains only one element. For CJK codepoints, it's common
   // to see 3-4 scripts. For really rare cases, the set can go above 20 scripts.
   TScriptsArray codepointScripts;
-  size_t const codepointScriptsCount = GetScriptExtensions(codepoint, codepointScripts);
+  size_t const codepointScriptsCount = static_cast<size_t>(GetScriptExtensions(codepoint, codepointScripts));
 
   // Implicit script 'inherited' is inheriting scripts from preceding codepoint.
   if (codepointScriptsCount == 1 && codepointScripts[0] == USCRIPT_INHERITED)
@@ -99,27 +99,27 @@ size_t ScriptSetIntersect(char32_t codepoint, TScriptsArray & inOutScripts, size
 //
 // Consider 3 characters with the script values {Kana}, {Hira, Kana}, {Kana}. Without script extensions only the first
 // script in each set would be taken into account, resulting in 3 segments where 1 would be enough.
-size_t ScriptInterval(std::u16string const & text, int32_t start, size_t length, UScriptCode & outScript)
+int32_t ScriptInterval(std::u16string const & text, int32_t start, int32_t length, UScriptCode & outScript)
 {
   ASSERT_GREATER(length, 0U, ());
 
   auto const begin = text.begin() + start;
-  auto const end = text.begin() + start + static_cast<int32_t>(length);
+  auto const end = text.begin() + start + length;
   auto iterator = begin;
 
   auto c32 = utf8::unchecked::next16(iterator);
 
   TScriptsArray scripts;
-  size_t scriptsSize = GetScriptExtensions(c32, scripts);
+  int32_t scriptsSize = GetScriptExtensions(c32, scripts);
 
   while (iterator != end)
   {
     auto prev = iterator;
     c32 = utf8::unchecked::next16(iterator);
     scriptsSize = ScriptSetIntersect(c32, scripts, scriptsSize);
-    if (scriptsSize == 0U)
+    if (scriptsSize == 0)
     {
-      length = prev - begin;
+      length = static_cast<int32_t>(prev - begin);
       break;
     }
   }
@@ -168,7 +168,7 @@ void GetSingleTextLineRuns(TextSegments & segments)
     {
       // Find the longest sequence of characters that have at least one common UScriptCode value.
       UScriptCode script = USCRIPT_INVALID_CODE;
-      size_t const scriptRunEnd =
+      int32_t const scriptRunEnd =
           ScriptInterval(segments.m_text, scriptRunStart, bidiRunEnd - scriptRunStart, script) + scriptRunStart;
       ASSERT_LESS(scriptRunStart, base::asserted_cast<int32_t>(scriptRunEnd), ());
 
@@ -179,7 +179,7 @@ void GetSingleTextLineRuns(TextSegments & segments)
                                        bidiLevel & 0x01 ? HB_DIRECTION_RTL : HB_DIRECTION_LTR);
 
       // Move to the next script sequence.
-      scriptRunStart = static_cast<int32_t>(scriptRunEnd);
+      scriptRunStart = scriptRunEnd;
     }
     // Move to the next direction sequence.
     bidiRunStart = bidiRunEnd;

libs/drape/harfbuzz_shaping.cpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "drape/drape_diagnostics.hpp"
+#include "drape/drape_global.hpp"
 #include "drape/utils/glyph_usage_tracker.hpp"
 #include "drape/utils/gpu_mem_tracker.hpp"
 
@@ -10,7 +11,6 @@
 #include "base/timer.hpp"
 
 #include <chrono>
-#include <drape/drape_global.hpp>
 #include <map>
 #include <memory>
 #include <mutex>