fix(SAMPLE-020): allow List<T> for an element type without equality

SAMPLE-020's TransformedCollision stores `List<Block>`, and `Block` declares no
equality of any kind. `List<T>::Contains`, `IndexOf` and `Remove` are overrides,
so they are instantiated with the class, and the `findValue` they share required
`operator==` on `T`. The container could therefore not be instantiated at all --
a restriction .NET's `List<T>` does not have, because the equality it needs comes
from `EqualityComparer<T>.Default` rather than from `T`.

`findValue` now refuses at the call instead of at instantiation: for a `T` that
is not `equality_comparable` it throws `NotSupportedException`, and every type
that does declare equality keeps the `std::find` path (and the NaN special case)
unchanged. Storage, index-based mutation and enumeration work for any `T`, which
is what the sample uses -- it removes blocks by index.

Seven tests cover storage, index-based mutation, enumeration, the three refusals
and the unchanged searching behaviour when equality does exist. Full suite after
the change: 17847/17847.

Author: robertvokac

modules/collections/tests/System/Collections/Generic/ListNonComparableElementTests.cpp

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) Robert Vokac and contributors
+// Portions based on .NET runtime API (MIT License, Copyright .NET Foundation and Contributors)
+#include <gtest/gtest.h>
+#include "System/Collections/Generic/List.hpp"
+#include "System/NotSupportedException.hpp"
+
+using namespace System::Collections::Generic;
+
+namespace {
+
+// A element type with no equality of any kind, the C++ counterpart of a plain C# class
+// that overrides neither Equals nor operator==.
+struct NoEquality {
+    float x = 0.0f;
+    int tag = 0;
+};
+
+} // namespace
+
+// A .NET List<T> is instantiable for every T, because the equality it needs comes from
+// EqualityComparer<T>.Default rather than from T itself. Everything that does not compare
+// elements must therefore work here too.
+TEST(ListNonComparableElementTests, StoresAndRetrievesElementsWithoutEquality) {
+    List<NoEquality> list;
+    list.Add(NoEquality{1.0f, 10});
+    list.Add(NoEquality{2.0f, 20});
+    list.Add(NoEquality{3.0f, 30});
+
+    EXPECT_EQ(list.getCountProperty(), 3);
+    EXPECT_EQ(list.getItem(0).tag, 10);
+    EXPECT_EQ(list.getItem(2).tag, 30);
+}
+
+TEST(ListNonComparableElementTests, IndexBasedMutationWorksWithoutEquality) {
+    List<NoEquality> list;
+    list.Add(NoEquality{1.0f, 10});
+    list.Add(NoEquality{2.0f, 20});
+
+    list.setItem(0, NoEquality{9.0f, 90});
+    EXPECT_EQ(list.getItem(0).tag, 90);
+
+    list.Insert(1, NoEquality{5.0f, 50});
+    EXPECT_EQ(list.getCountProperty(), 3);
+    EXPECT_EQ(list.getItem(1).tag, 50);
+
+    list.RemoveAt(1);
+    EXPECT_EQ(list.getCountProperty(), 2);
+    EXPECT_EQ(list.getItem(1).tag, 20);
+
+    list.Clear();
+    EXPECT_EQ(list.getCountProperty(), 0);
+}
+
+TEST(ListNonComparableElementTests, EnumerationWorksWithoutEquality) {
+    List<NoEquality> list;
+    list.Add(NoEquality{1.0f, 10});
+    list.Add(NoEquality{2.0f, 20});
+
+    int sum = 0;
+    for (const NoEquality& item : list) {
+        sum += item.tag;
+    }
+    EXPECT_EQ(sum, 30);
+}
+
+// The members that do compare elements have no counterpart for such a T, and say so
+// instead of silently answering with something arbitrary.
+TEST(ListNonComparableElementTests, ContainsThrowsNotSupportedWithoutEquality) {
+    List<NoEquality> list;
+    list.Add(NoEquality{1.0f, 10});
+
+    EXPECT_THROW((void)list.Contains(NoEquality{1.0f, 10}), System::NotSupportedException);
+}
+
+TEST(ListNonComparableElementTests, IndexOfThrowsNotSupportedWithoutEquality) {
+    List<NoEquality> list;
+    list.Add(NoEquality{1.0f, 10});
+
+    EXPECT_THROW((void)list.IndexOf(NoEquality{1.0f, 10}), System::NotSupportedException);
+}
+
+TEST(ListNonComparableElementTests, RemoveThrowsNotSupportedWithoutEquality) {
+    List<NoEquality> list;
+    list.Add(NoEquality{1.0f, 10});
+
+    EXPECT_THROW((void)list.Remove(NoEquality{1.0f, 10}), System::NotSupportedException);
+    EXPECT_EQ(list.getCountProperty(), 1);
+}
+
+// An element type that does declare equality keeps the ordinary searching behaviour.
+namespace {
+
+struct WithEquality {
+    int tag = 0;
+    bool operator==(const WithEquality& other) const { return tag == other.tag; }
+};
+
+} // namespace
+
+TEST(ListNonComparableElementTests, SearchingStillWorksWhenEqualityExists) {
+    List<WithEquality> list;
+    list.Add(WithEquality{10});
+    list.Add(WithEquality{20});
+
+    EXPECT_TRUE(list.Contains(WithEquality{20}));
+    EXPECT_EQ(list.IndexOf(WithEquality{20}), 1);
+    EXPECT_TRUE(list.Remove(WithEquality{10}));
+    EXPECT_EQ(list.getCountProperty(), 1);
+    EXPECT_EQ(list.getItem(0).tag, 20);
+}

modules/core/include/System/detail/ComparisonPolicy.hpp

@@ -4,6 +4,7 @@
 #pragma once
 #include <algorithm>
 #include <cmath>
+#include <concepts>
 #include <cstddef>
 #include <functional>
 #include <iterator>
@@ -12,6 +13,8 @@
 #include <type_traits>
 #include <utility>
 
+#include "System/NotSupportedException.hpp"
+
 namespace System::detail {
 
 /**
@@ -185,13 +188,28 @@ template<typename T>
  */
 template<typename It, typename T>
 [[nodiscard]] It findValue(It first, It last, const T& value) {
-    if constexpr (std::is_floating_point_v<typename std::iterator_traits<It>::value_type>) {
-        if (std::isnan(value)) {
-            return std::find_if(first, last,
-                                [](const auto& v) { return std::isnan(v); });
+    if constexpr (!std::equality_comparable<T>) {
+        // .NET reaches `EqualityComparer<T>.Default` here, which exists for every T: a
+        // reference type with no Equals override falls back to reference equality. This
+        // port stores elements by value, so a type that declares no equality has nothing
+        // to compare and no reference identity to fall back on. Refusing at the call is
+        // what keeps `List<T>` and `Array` usable for such a T at all -- a hard
+        // requirement on `operator==` would make the container itself uninstantiable,
+        // which C#'s never is.
+        (void)first; (void)last; (void)value;
+        throw System::NotSupportedException(
+            "This element type declares no equality, so the .NET EqualityComparer<T>.Default "
+            "search this method performs has no counterpart. Give the type an operator== to "
+            "make Contains/IndexOf/Remove meaningful for it.");
+    } else {
+        if constexpr (std::is_floating_point_v<typename std::iterator_traits<It>::value_type>) {
+            if (std::isnan(value)) {
+                return std::find_if(first, last,
+                                    [](const auto& v) { return std::isnan(v); });
+            }
         }
+        return std::find(first, last, value);
     }
-    return std::find(first, last, value);
 }
 
 /**