Implement support for unspeakable types. (#83631)

* Implement support for unspeakable types.

* Remove unneeded declarations.

* Record ambiguity information in exception message.

* Fix error message testing in wasm.

* Address feedback.

* Add test case for interface POCOs

* Update src/libraries/System.Text.Json/src/Resources/Strings.resx

Co-authored-by: Dan Moseley <[email protected]>

---------

Co-authored-by: Dan Moseley <[email protected]>

Author: eiriktsarpalis

src/libraries/System.Text.Json/src/Resources/Strings.resx

@@ -594,7 +594,10 @@
     <value>The generic type of the converter for property '{0}.{1}' must match with the specified converter type '{2}'. The converter must not be 'null'.</value>
   </data>
   <data name="NoMetadataForType" xml:space="preserve">
-    <value>Metadata for type '{0}' was not provided by TypeInfoResolver of type '{1}'. If using source generation, ensure that all root types passed to the serializer have been indicated with 'JsonSerializableAttribute', along with any types that might be serialized polymorphically.</value>
+    <value>JsonTypeInfo metadata for type '{0}' was not provided by TypeInfoResolver of type '{1}'. If using source generation, ensure that all root types passed to the serializer have been annotated with 'JsonSerializableAttribute', along with any types that might be serialized polymorphically.</value>
+  </data>
+  <data name="AmbiguousMetadataForType" xml:space="preserve">
+    <value>Ambiguous matches when resolving JsonTypeInfo metadata for type '{0}': '{1}', '{2}'. Consider either explicitly providing metadata for the type or removing one of its interface implementations.</value>
   </data>
   <data name="CollectionIsReadOnly" xml:space="preserve">
     <value>Collection is read-only.</value>

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Helpers.cs

@@ -15,7 +15,7 @@ public static partial class JsonSerializer
 
         [RequiresUnreferencedCode(SerializationUnreferencedCodeMessage)]
         [RequiresDynamicCode(SerializationRequiresDynamicCodeMessage)]
-        private static JsonTypeInfo GetTypeInfo(JsonSerializerOptions? options, Type inputType)
+        private static JsonTypeInfo GetTypeInfo(JsonSerializerOptions? options, Type inputType, bool fallBackToNearestAncestorType = false)
         {
             Debug.Assert(inputType != null);
 
@@ -31,7 +31,7 @@ private static JsonTypeInfo GetTypeInfo(JsonSerializerOptions? options, Type inp
             // This lets any derived types take advantage of the cache in GetTypeInfoForRootType themselves.
             return inputType == JsonTypeInfo.ObjectType
                 ? options.ObjectTypeInfo
-                : options.GetTypeInfoForRootType(inputType);
+                : options.GetTypeInfoForRootType(inputType, fallBackToNearestAncestorType);
         }
 
         [RequiresUnreferencedCode(SerializationUnreferencedCodeMessage)]

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Write.ByteArray.cs

@@ -55,7 +55,7 @@ public static byte[] SerializeToUtf8Bytes(
             JsonSerializerOptions? options = null)
         {
             ValidateInputType(value, inputType);
-            JsonTypeInfo jsonTypeInfo = GetTypeInfo(options, inputType);
+            JsonTypeInfo jsonTypeInfo = GetTypeInfo(options, inputType, fallBackToNearestAncestorType: true);
             return WriteBytesAsObject(value, jsonTypeInfo);
         }
 

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Write.Document.cs

@@ -51,7 +51,7 @@ public static JsonDocument SerializeToDocument<TValue>(TValue value, JsonSeriali
         public static JsonDocument SerializeToDocument(object? value, Type inputType, JsonSerializerOptions? options = null)
         {
             ValidateInputType(value, inputType);
-            JsonTypeInfo jsonTypeInfo = GetTypeInfo(options, inputType);
+            JsonTypeInfo jsonTypeInfo = GetTypeInfo(options, inputType, fallBackToNearestAncestorType: true);
             return WriteDocumentAsObject(value, jsonTypeInfo);
         }
 

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Write.Element.cs

@@ -51,7 +51,7 @@ public static JsonElement SerializeToElement<TValue>(TValue value, JsonSerialize
         public static JsonElement SerializeToElement(object? value, Type inputType, JsonSerializerOptions? options = null)
         {
             ValidateInputType(value, inputType);
-            JsonTypeInfo jsonTypeInfo = GetTypeInfo(options, inputType);
+            JsonTypeInfo jsonTypeInfo = GetTypeInfo(options, inputType, fallBackToNearestAncestorType: true);
             return WriteElementAsObject(value, jsonTypeInfo);
         }
 

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Write.Node.cs

@@ -52,7 +52,7 @@ public static partial class JsonSerializer
         public static JsonNode? SerializeToNode(object? value, Type inputType, JsonSerializerOptions? options = null)
         {
             ValidateInputType(value, inputType);
-            JsonTypeInfo typeInfo = GetTypeInfo(options, inputType);
+            JsonTypeInfo typeInfo = GetTypeInfo(options, inputType, fallBackToNearestAncestorType: true);
             return WriteNodeAsObject(value, typeInfo);
         }
 

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Write.Stream.cs

@@ -117,7 +117,7 @@ public static Task SerializeAsync(
             }
 
             ValidateInputType(value, inputType);
-            JsonTypeInfo jsonTypeInfo = GetTypeInfo(options, inputType);
+            JsonTypeInfo jsonTypeInfo = GetTypeInfo(options, inputType, fallBackToNearestAncestorType: true);
             return jsonTypeInfo.SerializeAsObjectAsync(utf8Json, value, cancellationToken);
         }
 
@@ -152,7 +152,7 @@ public static void Serialize(
             }
 
             ValidateInputType(value, inputType);
-            JsonTypeInfo jsonTypeInfo = GetTypeInfo(options, inputType);
+            JsonTypeInfo jsonTypeInfo = GetTypeInfo(options, inputType, fallBackToNearestAncestorType: true);
             jsonTypeInfo.SerializeAsObject(utf8Json, value);
         }
 

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Write.String.cs

@@ -62,7 +62,7 @@ public static string Serialize(
             JsonSerializerOptions? options = null)
         {
             ValidateInputType(value, inputType);
-            JsonTypeInfo jsonTypeInfo = GetTypeInfo(options, inputType);
+            JsonTypeInfo jsonTypeInfo = GetTypeInfo(options, inputType, fallBackToNearestAncestorType: true);
             return WriteStringAsObject(value, jsonTypeInfo);
         }
 

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Write.Utf8JsonWriter.cs

@@ -70,7 +70,7 @@ public static void Serialize(
             }
 
             ValidateInputType(value, inputType);
-            JsonTypeInfo jsonTypeInfo = GetTypeInfo(options, inputType);
+            JsonTypeInfo jsonTypeInfo = GetTypeInfo(options, inputType, fallBackToNearestAncestorType: true);
             jsonTypeInfo.SerializeAsObject(writer, value);
         }
 

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializerOptions.Caching.cs

@@ -6,9 +6,9 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
 using System.Text.Json.Serialization;
 using System.Text.Json.Serialization.Metadata;
-using System.Threading;
 
 namespace System.Text.Json
 {
@@ -62,13 +62,19 @@ public JsonTypeInfo GetTypeInfo(Type type)
         /// <summary>
         /// Same as GetTypeInfo but without validation and additional knobs.
         /// </summary>
-        internal JsonTypeInfo GetTypeInfoInternal(Type type, bool ensureConfigured = true, bool resolveIfMutable = false)
+        internal JsonTypeInfo GetTypeInfoInternal(
+            Type type,
+            bool ensureConfigured = true,
+            bool resolveIfMutable = false,
+            bool fallBackToNearestAncestorType = false)
         {
+            Debug.Assert(!fallBackToNearestAncestorType || IsReadOnly, "ancestor resolution should only be invoked in read-only options.");
+
             JsonTypeInfo? typeInfo = null;
 
             if (IsReadOnly)
             {
-                typeInfo = CacheContext.GetOrAddTypeInfo(type);
+                typeInfo = CacheContext.GetOrAddTypeInfo(type, fallBackToNearestAncestorType);
                 if (ensureConfigured)
                 {
                     typeInfo?.EnsureConfigured();
@@ -95,21 +101,20 @@ internal bool TryGetTypeInfoCached(Type type, [NotNullWhen(true)] out JsonTypeIn
                 return false;
             }
 
-            return _cachingContext.TryGetJsonTypeInfo(type, out typeInfo);
+            return _cachingContext.TryGetTypeInfo(type, out typeInfo);
         }
 
         /// <summary>
         /// Return the TypeInfo for root API calls.
         /// This has an LRU cache that is intended only for public API calls that specify the root type.
         /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal JsonTypeInfo GetTypeInfoForRootType(Type type)
+        internal JsonTypeInfo GetTypeInfoForRootType(Type type, bool fallBackToNearestAncestorType = false)
         {
             JsonTypeInfo? jsonTypeInfo = _lastTypeInfo;
 
             if (jsonTypeInfo?.Type != type)
             {
-                _lastTypeInfo = jsonTypeInfo = GetTypeInfoInternal(type);
+                _lastTypeInfo = jsonTypeInfo = GetTypeInfoInternal(type, fallBackToNearestAncestorType: fallBackToNearestAncestorType);
             }
 
             return jsonTypeInfo;
@@ -122,7 +127,7 @@ internal bool TryGetPolymorphicTypeInfoForRootType(object rootValue, [NotNullWhe
             Type runtimeType = rootValue.GetType();
             if (runtimeType != JsonTypeInfo.ObjectType)
             {
-                polymorphicTypeInfo = GetTypeInfoForRootType(runtimeType);
+                polymorphicTypeInfo = GetTypeInfoForRootType(runtimeType, fallBackToNearestAncestorType: true);
                 return true;
             }
 
@@ -157,39 +162,182 @@ internal void ClearCaches()
         /// </summary>
         internal sealed class CachingContext
         {
-            private readonly ConcurrentDictionary<Type, JsonTypeInfo?> _jsonTypeInfoCache = new();
+            private readonly ConcurrentDictionary<Type, CacheEntry> _cache = new();
 #if !NETCOREAPP
-            private readonly Func<Type, JsonTypeInfo?> _jsonTypeInfoFactory;
+            private readonly Func<Type, CacheEntry> _cacheEntryFactory;
 #endif
 
             public CachingContext(JsonSerializerOptions options, int hashCode)
             {
                 Options = options;
                 HashCode = hashCode;
 #if !NETCOREAPP
-                _jsonTypeInfoFactory = Options.GetTypeInfoNoCaching;
+                _cacheEntryFactory = type => CreateCacheEntry(type, this);
 #endif
             }
 
             public JsonSerializerOptions Options { get; }
             public int HashCode { get; }
             // Property only accessed by reflection in testing -- do not remove.
             // If changing please ensure that src/ILLink.Descriptors.LibraryBuild.xml is up-to-date.
-            public int Count => _jsonTypeInfoCache.Count;
+            public int Count => _cache.Count;
+
+            public JsonTypeInfo? GetOrAddTypeInfo(Type type, bool fallBackToNearestAncestorType = false)
+            {
+                CacheEntry entry = GetOrAddCacheEntry(type);
+                return fallBackToNearestAncestorType && !entry.HasResult
+                    ? FallBackToNearestAncestor(type, entry)
+                    : entry.GetResult();
+            }
+
+            public bool TryGetTypeInfo(Type type, [NotNullWhen(true)] out JsonTypeInfo? typeInfo)
+            {
+                _cache.TryGetValue(type, out CacheEntry? entry);
+                typeInfo = entry?.TypeInfo;
+                return typeInfo is not null;
+            }
 
-            public JsonTypeInfo? GetOrAddTypeInfo(Type type) =>
+            public void Clear()
+            {
+                _cache.Clear();
+            }
+
+            private CacheEntry GetOrAddCacheEntry(Type type)
+            {
 #if NETCOREAPP
-                _jsonTypeInfoCache.GetOrAdd(type, static (type, options) => options.GetTypeInfoNoCaching(type), Options);
+                return _cache.GetOrAdd(type, CreateCacheEntry, this);
 #else
-                _jsonTypeInfoCache.GetOrAdd(type, _jsonTypeInfoFactory);
+                return _cache.GetOrAdd(type, _cacheEntryFactory);
 #endif
+            }
 
-            public bool TryGetJsonTypeInfo(Type type, [NotNullWhen(true)] out JsonTypeInfo? typeInfo)
-                => _jsonTypeInfoCache.TryGetValue(type, out typeInfo);
+            private static CacheEntry CreateCacheEntry(Type type, CachingContext context)
+            {
+                try
+                {
+                    JsonTypeInfo? typeInfo = context.Options.GetTypeInfoNoCaching(type);
+                    return new CacheEntry(typeInfo);
+                }
+                catch (Exception ex)
+                {
+                    ExceptionDispatchInfo edi = ExceptionDispatchInfo.Capture(ex);
+                    return new CacheEntry(edi);
+                }
+            }
 
-            public void Clear()
+            private JsonTypeInfo? FallBackToNearestAncestor(Type type, CacheEntry entry)
+            {
+                Debug.Assert(!entry.HasResult);
+
+                CacheEntry? nearestAncestor = entry.IsNearestAncestorResolved
+                    ? entry.NearestAncestor
+                    : DetermineNearestAncestor(type, entry);
+
+                return nearestAncestor?.GetResult();
+            }
+
+            [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern",
+                Justification = "We only need to examine the interface types that are supported by the underlying resolver.")]
+            private CacheEntry? DetermineNearestAncestor(Type type, CacheEntry entry)
+            {
+                // In cases where the underlying TypeInfoResolver returns `null` for a given type,
+                // this method traverses the hierarchy above the given type to determine potential
+                // ancestors for which the resolver does provide metadata. This can be useful in
+                // cases where we're using a source generator and are trying to serialize private
+                // implementations of an interface that is supported by the source generator.
+                // NB this algorithm runs lazily and unsynchronized *after* the CacheEntry has been looked up
+                // from the global cache, so care should be taken to avoid potential race conditions.
+                //
+                // IMPORTANT: nearest-ancestor resolution should be reserved for weakly-typed serialization.
+                // Attempting to use it in strongly typed operations or deserialization will invariably
+                // result in an invalid cast exception, so use with caution.
+
+                Debug.Assert(!entry.HasResult);
+                CacheEntry? candidate = null;
+                Type? candidateType = null;
+
+                for (Type? current = type.BaseType; current != null; current = current.BaseType)
+                {
+                    if (current == JsonTypeInfo.ObjectType)
+                    {
+                        // Avoid falling back to the contract for object since it's polymorphic
+                        // and it would try to send us back to the runtime type that isn't supported.
+                        break;
+                    }
+
+                    candidate = GetOrAddCacheEntry(current);
+                    if (candidate.HasResult)
+                    {
+                        // We found a type in the class hierarchy that has a contract -- stop looking further up.
+                        candidateType = current;
+                        break;
+                    }
+                }
+
+                foreach (Type interfaceType in type.GetInterfaces())
+                {
+                    CacheEntry interfaceEntry = GetOrAddCacheEntry(interfaceType);
+                    if (interfaceEntry.HasResult)
+                    {
+                        if (candidateType != null)
+                        {
+                            if (interfaceType.IsAssignableFrom(candidateType))
+                            {
+                                // The previous candidate is more derived than the
+                                // current interface -- keep our previous choice.
+                                continue;
+                            }
+                            else if (candidateType.IsAssignableFrom(interfaceType))
+                            {
+                                // The current interface is more derived than the
+                                // previous candidate -- replace the candidate value.
+                            }
+                            else
+                            {
+                                // We have found two possible ancestors that are not in subtype relationship.
+                                // This indicates we have encountered a diamond ambiguity -- abort search and record an exception.
+                                NotSupportedException nse = ThrowHelper.GetNotSupportedException_AmbiguousMetadataForType(type, candidateType, interfaceType);
+                                candidate = new CacheEntry(ExceptionDispatchInfo.Capture(nse));
+                                break;
+                            }
+                        }
+
+                        candidate = interfaceEntry;
+                        candidateType = interfaceType;
+                    }
+                }
+
+                entry.NearestAncestor = candidate;
+                entry.IsNearestAncestorResolved = true;
+                return candidate;
+            }
+
+            private sealed class CacheEntry
             {
-                _jsonTypeInfoCache.Clear();
+                public readonly bool HasResult;
+                public readonly JsonTypeInfo? TypeInfo;
+                public readonly ExceptionDispatchInfo? ExceptionDispatchInfo;
+
+                public volatile bool IsNearestAncestorResolved;
+                public CacheEntry? NearestAncestor;
+
+                public CacheEntry(JsonTypeInfo? typeInfo)
+                {
+                    TypeInfo = typeInfo;
+                    HasResult = typeInfo is not null;
+                }
+
+                public CacheEntry(ExceptionDispatchInfo exception)
+                {
+                    ExceptionDispatchInfo = exception;
+                    HasResult = true;
+                }
+
+                public JsonTypeInfo? GetResult()
+                {
+                    ExceptionDispatchInfo?.Throw();
+                    return TypeInfo;
+                }
             }
         }