Improved reporting on unsupported types by the Json Serialization

The Json Serialization currently doesn't support AZStd::any, AZStd::variant and AZStd::optional due to various JSON formatting concerns. This wasn't properly reported resulting in confusion about whether the missing functionality is intentional or a bug. This change makes this explicit with an error message.
As this solution uses a custom json serializer to report the issue, an option was added so it's possible to overwrite a serializer for a specific type.
This doesn't mean that the three listed types will never be supported. If/when a suitable format is found an implementation will be added.

Code/Framework/AzCore/Tests/Serialization/Json/JsonRegistrationContextTests.cpp

@@ -95,6 +95,20 @@ namespace JsonSerializationTests
         }
     };
 
+    class SerializerWithOneDuplicatedTypeWithOverride
+        : public JsonSerializerTemplatedMock<SerializerWithOneDuplicatedTypeWithOverride>
+    {
+    public:
+        AZ_RTTI(SerializerWithOneDuplicatedTypeWithOverride, "{4218D591-E578-499B-B578-ACA70C9944AB}", BaseJsonSerializer);
+        ~SerializerWithOneDuplicatedTypeWithOverride() override = default;
+
+        static void Reflect(AZ::JsonRegistrationContext* context)
+        {
+            context->Serializer<SerializerWithOneDuplicatedTypeWithOverride>()
+                ->HandlesType<bool>(true);
+        }
+    };
+
     // Attempts to register the same type twice
     class SerializerWithTwoSameTypes
         : public JsonSerializerTemplatedMock<SerializerWithTwoSameTypes>
@@ -278,6 +292,22 @@ namespace JsonSerializationTests
         SerializerWithOneDuplicatedType::Unreflect(m_jsonRegistrationContext.get());
     }
 
+    TEST_F(JsonRegistrationContextTests, OverwriteRegisterSameUuidWithMultipleSerializers_Succeeds)
+    {
+        EXPECT_NE(AZ::AzTypeInfo<SerializerWithOneDuplicatedTypeWithOverride>::Uuid(), AZ::AzTypeInfo<SerializerWithOneType>::Uuid());
+
+        SerializerWithOneType::Reflect(m_jsonRegistrationContext.get());
+        SerializerWithOneDuplicatedTypeWithOverride::Reflect(m_jsonRegistrationContext.get());
+        
+        EXPECT_EQ(1, m_jsonRegistrationContext->GetRegisteredSerializers().size());
+        AZ::BaseJsonSerializer* mockSerializer = m_jsonRegistrationContext->GetSerializerForType(azrtti_typeid<bool>());
+        EXPECT_NE(mockSerializer, nullptr);
+        EXPECT_EQ(AZ::AzTypeInfo<SerializerWithOneDuplicatedTypeWithOverride>::Uuid(), mockSerializer->RTTI_GetType());
+
+        SerializerWithOneType::Unreflect(m_jsonRegistrationContext.get());
+        SerializerWithOneDuplicatedTypeWithOverride::Unreflect(m_jsonRegistrationContext.get());
+    }
+
     TEST_F(JsonRegistrationContextTests, RegisterSameUuidWithSameSerializers_Fails)
     {
         AZ_TEST_START_ASSERTTEST;

Code/Framework/AzCore/Tests/Serialization/Json/UnsupportedTypesSerializerTests.cpp

@@ -0,0 +1,143 @@
+/*
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
+
+#include <AzCore/Serialization/Json/UnsupportedTypesSerializer.h>
+#include <AzCore/std/any.h>
+#include <AzCore/std/optional.h>
+#include <AzCore/std/containers/variant.h>
+#include <Tests/Serialization/Json/BaseJsonSerializerFixture.h>
+
+namespace JsonSerializationTests
+{
+    struct AnyInfo
+    {
+        using Type = AZStd::any;
+        using Serializer = AZ::JsonAnySerializer;
+    };
+
+    struct VariantInfo
+    {
+        using Type = AZStd::variant<AZStd::monostate, int, double>;
+        using Serializer = AZ::JsonVariantSerializer;
+    };
+
+    struct OptionalInfo
+    {
+        using Type = AZStd::optional<int>;
+        using Serializer = AZ::JsonVariantSerializer;
+    };
+
+    template<typename Info>
+    class JsonUnsupportedTypesSerializerTests : public BaseJsonSerializerFixture
+    {
+    public:
+        using Type = typename Info::Type;
+        using Serializer = typename Info::Serializer;
+
+        void SetUp() override
+        {
+            BaseJsonSerializerFixture::SetUp();
+            m_serializer = AZStd::make_unique<Serializer>();
+        }
+
+        void TearDown() override
+        {
+            m_serializer.reset();
+            BaseJsonSerializerFixture::TearDown();
+        }
+
+    protected:
+        AZStd::unique_ptr<Serializer> m_serializer;
+    };
+
+    using UnsupportedTypesTestTypes = ::testing::Types<AnyInfo, VariantInfo, OptionalInfo>;
+    TYPED_TEST_CASE(JsonUnsupportedTypesSerializerTests, UnsupportedTypesTestTypes);
+
+    TYPED_TEST(JsonUnsupportedTypesSerializerTests, Load_CallDirectly_ReportsIssueAndHalts)
+    {
+        using namespace AZ::JsonSerializationResult;
+
+        bool hasMessage = false;
+        auto callback = [&hasMessage](AZStd::string_view message, ResultCode result, AZStd::string_view) -> ResultCode
+        {
+            hasMessage = !message.empty();
+            return result;
+        };
+        m_jsonDeserializationContext->PushReporter(AZStd::move(callback));
+
+        Type instance{};
+        Result result = m_serializer->Load(&instance, azrtti_typeid<Type>(), *m_jsonDocument, *m_jsonDeserializationContext);
+        m_jsonDeserializationContext->PopReporter();
+
+        EXPECT_EQ(Processing::Halted, result.GetResultCode().GetProcessing());
+        EXPECT_TRUE(hasMessage);
+    }
+
+    TYPED_TEST(JsonUnsupportedTypesSerializerTests, Load_CallThroughFrontEnd_ReportsIssueAndHalts)
+    {
+        using namespace AZ::JsonSerializationResult;
+
+        bool hasMessage = false;
+        auto callback = [&hasMessage](AZStd::string_view message, ResultCode result, AZStd::string_view) -> ResultCode
+        {
+            hasMessage = !message.empty();
+            return result;
+        };
+        m_deserializationSettings->m_reporting = AZStd::move(callback);
+        
+        Type instance{};
+        ResultCode result = AZ::JsonSerialization::Load(instance, *m_jsonDocument, *m_deserializationSettings);
+        
+        EXPECT_EQ(Processing::Halted, result.GetProcessing());
+        EXPECT_TRUE(hasMessage);
+    }
+
+    TYPED_TEST(JsonUnsupportedTypesSerializerTests, Save_CallDirectly_ReportsIssueAndHalts)
+    {
+        using namespace AZ::JsonSerializationResult;
+
+        bool hasMessage = false;
+        auto callback = [&hasMessage](AZStd::string_view message, ResultCode result, AZStd::string_view) -> ResultCode
+        {
+            hasMessage = !message.empty();
+            return result;
+        };
+        m_jsonSerializationContext->PushReporter(AZStd::move(callback));
+
+        Type instance{};
+        Result result = m_serializer->Store(*m_jsonDocument, &instance, nullptr, azrtti_typeid<Type>(), *m_jsonSerializationContext);
+        m_jsonSerializationContext->PopReporter();
+
+        EXPECT_EQ(Processing::Halted, result.GetResultCode().GetProcessing());
+        EXPECT_TRUE(hasMessage);
+    }
+
+    TYPED_TEST(JsonUnsupportedTypesSerializerTests, Save_CallThroughFrontEnd_ReportsIssueAndHalts)
+    {
+        using namespace AZ::JsonSerializationResult;
+
+        bool hasMessage = false;
+        auto callback = [&hasMessage](AZStd::string_view message, ResultCode result, AZStd::string_view) -> ResultCode
+        {
+            hasMessage = !message.empty();
+            return result;
+        };
+        m_serializationSettings->m_reporting = AZStd::move(callback);
+        
+        Type instance{};
+        ResultCode result =
+            AZ::JsonSerialization::Store(*m_jsonDocument, m_jsonDocument->GetAllocator(), instance, *m_serializationSettings);
+
+        EXPECT_EQ(Processing::Halted, result.GetProcessing());
+        EXPECT_TRUE(hasMessage);
+    }
+} // namespace JsonSerializationTests

Code/Framework/AzCore/Tests/azcoretests_files.cmake

@@ -128,6 +128,7 @@ set(FILES
     Serialization/Json/TransformSerializerTests.cpp
     Serialization/Json/TupleSerializerTests.cpp
     Serialization/Json/UnorderedSetSerializerTests.cpp
+    Serialization/Json/UnsupportedTypesSerializerTests.cpp
     Serialization/Json/UuidSerializerTests.cpp
     Math/AabbTests.cpp
     Math/ColorTests.cpp