fixed some bugs indicated by msvc extra warnings

arBmind · arBmind · commit 49b628a5a7cb · 2023-11-22T22:43:27.000+01:00
diff --git a/src/array19.lib/array19/DynamicArrayOf.h b/src/array19.lib/array19/DynamicArrayOf.h
@@ -120,10 +120,10 @@ template<class T> struct DynamicArrayOf final {
     [[nodiscard]] auto move() -> MoveSlice { return MoveSlice{amendBegin(), m_count}; }
 
     void ensureCapacity(Count count) {
-        if (totalCapacity() < count) growBy(count - totalCapacity());
+        if (totalCapacity() < count) growBy(static_cast<size_t>(count - totalCapacity()));
     }
     void ensureUnusedCapacity(Count count) {
-        if (unusedCapacity() < count) growBy(count - unusedCapacity());
+        if (unusedCapacity() < count) growBy(static_cast<size_t>(count - unusedCapacity()));
     }
 
     void clear() {
diff --git a/src/array19.lib/array19/SliceOf.equals.h b/src/array19.lib/array19/SliceOf.equals.h
@@ -8,11 +8,9 @@ namespace array19 {
 template<class T> constexpr bool operator==(const SliceOf<T>& a, const SliceOf<T>& b) {
     if (a.count() != b.count()) return false;
     for (size_t i = 0u; i < a.count() && i < b.count(); i++) {
-        if (!(a[i] == b[i])) return false;
+        if (a[i] != b[i]) return false;
     }
     return true;
 }
 
-template<class T> constexpr bool operator!=(const SliceOf<T>& a, const SliceOf<T>& b) { return !(a == b); }
-
 } // namespace array19
diff --git a/src/array19.lib/array19/WithIndex.h b/src/array19.lib/array19/WithIndex.h
@@ -28,13 +28,13 @@ template<class C> struct WithIndex {
         constexpr auto operator++() -> iterator& { return (++it, ++index, *this); }
     };
 
-    constexpr WithIndex(C& c) noexcept : c(c) {}
+    constexpr WithIndex(C& c) noexcept : c(&c) {}
 
-    [[nodiscard]] constexpr auto begin() -> iterator { return iterator{adlBegin(c), {}}; }
-    [[nodiscard]] constexpr auto end() -> It { return adlEnd(c); }
+    [[nodiscard]] constexpr auto begin() -> iterator { return iterator{adlBegin(*c), {}}; }
+    [[nodiscard]] constexpr auto end() -> It { return adlEnd(*c); }
 
 private:
-    C& c;
+    C* c;
 };
 
 template<class C> WithIndex(C&) -> WithIndex<C>;
diff --git a/src/array19.lib/array19/WithIndex.test.cpp b/src/array19.lib/array19/WithIndex.test.cpp
@@ -5,7 +5,7 @@ using namespace array19;
 void constexpr_WithIndex_test() {
     constexpr auto sum = [] {
         int a[] = {1, 2, 3};
-        auto r = 0;
+        auto r = size_t{};
 #ifdef _MSC_VER
         auto wi = WithIndex{a}; // cl crashes if we inline this && run it as constexpr
         for (auto [v, i] : wi) {
diff --git a/src/enum19.lib/enum19/Enum.h b/src/enum19.lib/enum19/Enum.h
@@ -89,7 +89,7 @@ constexpr auto buildMetaEnumFor(
             index++,
             memberNames[nameIndex++],
             ((value = members.filled ? members.value : nextValue),
-             nextValue = value + 1,
+             nextValue = static_cast<Underlying>(value + 1),
              static_cast<Enum>(value)) //
         }...} //
     };
diff --git a/src/enum19.lib/enum19/visitEnumMemberNames.h b/src/enum19.lib/enum19/visitEnumMemberNames.h
@@ -16,7 +16,7 @@ constexpr bool isCppIdentifierChar(char c) {
 
 template<size_t N> constexpr auto extractEnumMemberNames(StringView body) -> Array<StringView, N> {
     auto result = Array<StringView, N>{};
-    auto i = 0;
+    auto i = 0u;
     auto p = body.data;
     auto e = body.data + body.count;
 
diff --git a/src/lookup19.lib/lookup19/OrderedSetOf.h b/src/lookup19.lib/lookup19/OrderedSetOf.h
@@ -57,10 +57,10 @@ template<class T, class Less = DefaultLess> struct OrderedSetOf {
     [[nodiscard]] operator Slice() const noexcept { return Slice{begin(), m_count}; }
 
     void ensureCapacity(Count count) {
-        if (totalCapacity() < count) growBy(count - totalCapacity());
+        if (totalCapacity() < count) growBy(static_cast<size_t>(count - totalCapacity()));
     }
     void ensureUnusedCapacity(Count count) {
-        if (unusedCapacity() < count) growBy(count);
+        if (unusedCapacity() < count) growBy(static_cast<size_t>(count - unusedCapacity()));
     }
 
     /// inserts a single value to the set if it is not yet present
@@ -90,7 +90,7 @@ template<class T, class Less = DefaultLess> struct OrderedSetOf {
             return true;
         }
         if (it != end()) {
-            memmove(it + 1, it, end() - it);
+            memmove(it + 1, it, static_cast<size_t>(end() - it));
         }
         *it = v;
         m_count++;
@@ -103,7 +103,7 @@ template<class T, class Less = DefaultLess> struct OrderedSetOf {
     void remove(ConstIterator cIt) {
         auto it = const_cast<Iterator>(cIt);
         if (it + 1 != end()) {
-            memmove(it, it + 1, end() - it - 1);
+            memmove(it, it + 1, static_cast<size_t>(end() - it - 1));
         }
         m_count--;
     }
@@ -210,15 +210,15 @@ template<class T, class Less = DefaultLess> struct OrderedSetOf {
     }
 
 private:
-    [[nodiscard]] auto grownStorage(int growBy) const -> AmendableSlice {
+    [[nodiscard]] auto grownStorage(size_t growBy) const -> AmendableSlice {
         auto cur = m_capacity;
         auto res = (cur << 1) - (cur >> 1) + (cur >> 4); // * 1.563
         if (res < 5) res = 5;
         if (res < m_capacity + growBy) res = m_capacity + growBy;
         auto ptr = Utils::allocate(res);
         return AmendableSlice{ptr, res};
     }
-    void growBy(int by) {
+    void growBy(size_t by) {
         auto newStorage = grownStorage(by);
         memcpy(newStorage.begin(), m_pointer, m_count);
         Utils::deallocate(SliceOf{m_pointer, m_capacity});
diff --git a/src/serialize19.lib/serialize19/Codec.test.cpp b/src/serialize19.lib/serialize19/Codec.test.cpp
@@ -19,7 +19,7 @@ struct Person {
 template<class A> void serialize(A& a, std::string& s) {
     auto size = s.size();
     serialize(a, size);
-    if (a.mode == ArchiveMode::Read) {
+    if constexpr (A::mode == ArchiveMode::Read) {
         s.resize(size);
         for (auto i = 0U; i < size; i++) serialize(a, s[i]);
     }
diff --git a/src/serialize19.lib/serialize19/Endianess.h b/src/serialize19.lib/serialize19/Endianess.h
@@ -18,7 +18,7 @@ template<class T> auto endianFlipFor(T input) -> T {
         return input;
     else if constexpr (N == 2) {
         auto value = *(uint16_t*)&input;
-        value = (uint16_t)(value << 8) | (value >> 8);
+        value = static_cast<uint16_t>((value << 8) | (value >> 8));
         return *(T*)&value;
     }
     else if constexpr (N == 4) {
diff --git a/src/serialize19.lib/serialize19/serialize.std_bitset.h b/src/serialize19.lib/serialize19/serialize.std_bitset.h
@@ -7,7 +7,7 @@
 namespace serialize19 {
 
 template<Archive A, size_t size> void serialize(A& a, std::bitset<size>& bitset) {
-    if (a.mode == ArchiveMode::Read) {
+    if constexpr (A::mode == ArchiveMode::Read) {
         for (auto i = 0u; i < size;) {
             auto chunk = uint8_t{};
             serialize(a, chunk);
diff --git a/src/string19.lib/string19/Rope.Decimal.h b/src/string19.lib/string19/Rope.Decimal.h
@@ -22,7 +22,7 @@ template<int V> constexpr void ropeAppend(ADL*, char*& data, Decimal<V>*) {
     auto c = static_cast<int>(ropeCount(adl, decimal<V>));
     auto n = V < 0 ? -V : V;
     for (int o = c - 1; o >= 0; o--, n /= 10) data[o] = n % 10 + '0';
-    if (V < 0) data[0] = '-';
+    if constexpr (V < 0) data[0] = '-';
     data += c;
 }
 
diff --git a/src/string19.lib/string19/StringView.equals.h b/src/string19.lib/string19/StringView.equals.h
@@ -11,6 +11,4 @@ constexpr bool operator==(StringView a, StringView b) noexcept {
     return true;
 }
 
-constexpr bool operator!=(StringView a, StringView b) noexcept { return !(a == b); }
-
 } // namespace string19
diff --git a/src/variant19.lib/variant19/Variant.test.cpp b/src/variant19.lib/variant19/Variant.test.cpp
@@ -99,32 +99,32 @@ TEST(Variant, amendVisit) {
     using V = Variant<char, int, float>;
     V v1(3.14f), v2('c');
 
-    v1.amendVisit([](auto& value) { value += 3.2f; });
+    v1.amendVisit([](auto& value) { value += 3; });
     //    v1.amendVisit([](int& value) { value -= 1; }, [](char&) {}, [](float& value) { value += 1; });
 
     v1.visit([](auto value) {
         EXPECT_EQ(sizeof(value), sizeof(float));
-        EXPECT_EQ(value, 3.14f + 3.2f /*+ 1*/);
+        EXPECT_EQ(value, 3.14f + 3 /*+ 1*/);
     });
 
-    v2.amendVisit([](auto& value) { value += 3.2f; });
+    v2.amendVisit([](auto& value) { value += 3; });
     //    v2.amendVisit([](int& value) { value -= 1; }, [](char&) {}, [](float& value) { value += 1; });
     v2.visit([](auto value) {
         EXPECT_EQ(sizeof(value), sizeof(char));
         EXPECT_EQ(value, 'f');
     });
 }
 
-// TEST(Variant, overloaded) {
-//    auto v = Variant<char, int, float>{};
+TEST(Variant, overloaded) {
+    auto v = Variant<char, int, float>{};
 
-//    auto charVisitor = [](char) { return 1; };
-//    auto intVisitor = [](int) { return 2; };
-//    auto floatVisitor = [](float) { return 3; };
+    auto charVisitor = [](char) -> int { return 1; };
+    auto intVisitor = [](int) -> int { return 2; };
+    auto floatVisitor = [](float) -> int { return 3; };
 
-//    EXPECT_EQ(1, v.visit(charVisitor, intVisitor, floatVisitor));
-//    v = 1;
-//    EXPECT_EQ(2, v.visit(charVisitor, intVisitor, floatVisitor));
-//    v = 3.2f;
-//    EXPECT_EQ(3, v.visit(charVisitor, intVisitor, floatVisitor));
-//}
+    EXPECT_EQ(1, v.visitOverloaded(charVisitor, intVisitor, floatVisitor));
+    v = 1;
+    EXPECT_EQ(2, v.visitOverloaded(charVisitor, intVisitor, floatVisitor));
+    v = 3.2f;
+    EXPECT_EQ(3, v.visitOverloaded(charVisitor, intVisitor, floatVisitor));
+}

Original file line number	Diff line number	Diff line change
`@@ -120,10 +120,10 @@ template<class T> struct DynamicArrayOf final {`
`120`	`120`	`[[nodiscard]] auto move() -> MoveSlice { return MoveSlice{amendBegin(), m_count}; }`
`121`	`121`
`122`	`122`	`void ensureCapacity(Count count) {`
`123`		`- if (totalCapacity() < count) growBy(count - totalCapacity());`
	`123`	`+ if (totalCapacity() < count) growBy(static_cast<size_t>(count - totalCapacity()));`
`124`	`124`	`}`
`125`	`125`	`void ensureUnusedCapacity(Count count) {`
`126`		`- if (unusedCapacity() < count) growBy(count - unusedCapacity());`
	`126`	`+ if (unusedCapacity() < count) growBy(static_cast<size_t>(count - unusedCapacity()));`
`127`	`127`	`}`
`128`	`128`
`129`	`129`	`void clear() {`
Original file line number	Diff line number	Diff line change
`@@ -8,11 +8,9 @@ namespace array19 {`
`8`	`8`	`template<class T> constexpr bool operator==(const SliceOf<T>& a, const SliceOf<T>& b) {`
`9`	`9`	`if (a.count() != b.count()) return false;`
`10`	`10`	`for (size_t i = 0u; i < a.count() && i < b.count(); i++) {`
`11`		`- if (!(a[i] == b[i])) return false;`
	`11`	`+ if (a[i] != b[i]) return false;`
`12`	`12`	`}`
`13`	`13`	`return true;`
`14`	`14`	`}`
`15`	`15`
`16`		`-template<class T> constexpr bool operator!=(const SliceOf<T>& a, const SliceOf<T>& b) { return !(a == b); }`
`17`		`-`
`18`	`16`	`} // namespace array19`
Original file line number	Diff line number	Diff line change
`@@ -57,10 +57,10 @@ template<class T, class Less = DefaultLess> struct OrderedSetOf {`
`57`	`57`	`[[nodiscard]] operator Slice() const noexcept { return Slice{begin(), m_count}; }`
`58`	`58`
`59`	`59`	`void ensureCapacity(Count count) {`
`60`		`- if (totalCapacity() < count) growBy(count - totalCapacity());`
	`60`	`+ if (totalCapacity() < count) growBy(static_cast<size_t>(count - totalCapacity()));`
`61`	`61`	`}`
`62`	`62`	`void ensureUnusedCapacity(Count count) {`
`63`		`- if (unusedCapacity() < count) growBy(count);`
	`63`	`+ if (unusedCapacity() < count) growBy(static_cast<size_t>(count - unusedCapacity()));`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`/// inserts a single value to the set if it is not yet present`
`@@ -90,7 +90,7 @@ template<class T, class Less = DefaultLess> struct OrderedSetOf {`
`90`	`90`	`return true;`
`91`	`91`	`}`
`92`	`92`	`if (it != end()) {`
`93`		`- memmove(it + 1, it, end() - it);`
	`93`	`+ memmove(it + 1, it, static_cast<size_t>(end() - it));`
`94`	`94`	`}`
`95`	`95`	`*it = v;`
`96`	`96`	`m_count++;`
`@@ -103,7 +103,7 @@ template<class T, class Less = DefaultLess> struct OrderedSetOf {`
`103`	`103`	`void remove(ConstIterator cIt) {`
`104`	`104`	`auto it = const_cast<Iterator>(cIt);`
`105`	`105`	`if (it + 1 != end()) {`
`106`		`- memmove(it, it + 1, end() - it - 1);`
	`106`	`+ memmove(it, it + 1, static_cast<size_t>(end() - it - 1));`
`107`	`107`	`}`
`108`	`108`	`m_count--;`
`109`	`109`	`}`
`@@ -210,15 +210,15 @@ template<class T, class Less = DefaultLess> struct OrderedSetOf {`
`210`	`210`	`}`
`211`	`211`
`212`	`212`	`private:`
`213`		`- [[nodiscard]] auto grownStorage(int growBy) const -> AmendableSlice {`
	`213`	`+ [[nodiscard]] auto grownStorage(size_t growBy) const -> AmendableSlice {`
`214`	`214`	`auto cur = m_capacity;`
`215`	`215`	`auto res = (cur << 1) - (cur >> 1) + (cur >> 4); // * 1.563`
`216`	`216`	`if (res < 5) res = 5;`
`217`	`217`	`if (res < m_capacity + growBy) res = m_capacity + growBy;`
`218`	`218`	`auto ptr = Utils::allocate(res);`
`219`	`219`	`return AmendableSlice{ptr, res};`
`220`	`220`	`}`
`221`		`- void growBy(int by) {`
	`221`	`+ void growBy(size_t by) {`
`222`	`222`	`auto newStorage = grownStorage(by);`
`223`	`223`	`memcpy(newStorage.begin(), m_pointer, m_count);`
`224`	`224`	`Utils::deallocate(SliceOf{m_pointer, m_capacity});`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ struct Person {`
`19`	`19`	`template<class A> void serialize(A& a, std::string& s) {`
`20`	`20`	`auto size = s.size();`
`21`	`21`	`serialize(a, size);`
`22`		`- if (a.mode == ArchiveMode::Read) {`
	`22`	`+ if constexpr (A::mode == ArchiveMode::Read) {`
`23`	`23`	`s.resize(size);`
`24`	`24`	`for (auto i = 0U; i < size; i++) serialize(a, s[i]);`
`25`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ template<class T> auto endianFlipFor(T input) -> T {`
`18`	`18`	`return input;`
`19`	`19`	`else if constexpr (N == 2) {`
`20`	`20`	`auto value = (uint16_t)&input;`
`21`		`- value = (uint16_t)(value << 8) \| (value >> 8);`
	`21`	`+ value = static_cast<uint16_t>((value << 8) \| (value >> 8));`
`22`	`22`	`return (T)&value;`
`23`	`23`	`}`
`24`	`24`	`else if constexpr (N == 4) {`