Fix recurisve issue with covariant interfaces and fix IID being wrong…

… for custom type mapped interfaces (#1297)
microsoft · Mar 14, 2023 · 8d8f1e1 · 8d8f1e1
1 parent ea463c3
commit 8d8f1e1
Show file tree

Hide file tree

Showing 5 changed files with 56 additions and 8 deletions.
diff --git a/src/Tests/UnitTest/GuidTests.cs b/src/Tests/UnitTest/GuidTests.cs
@@ -110,6 +110,12 @@ public void TestGenerics()
             AssertGuid<IList<Uri>>("0d82bd8d-fe62-5d67-a7b9-7886dd75bc4e");
             AssertGuid<IList<AsyncActionCompletedHandler>>("5dafe591-86dc-59aa-bfda-07f5d59fc708");
             AssertGuid<IList<ComposedNonBlittableStruct>>("c8477314-b257-511b-a3a1-9e4eb6385152");
+            AssertGuid<IList<IDisposable>>("1bfca4f6-2c4e-5174-9869-b39d35848fcc");
+            AssertGuid<IList<IWwwFormUrlDecoderEntry>>("2f5fb6d3-231f-57a1-9f2a-daa7e43bf075");
+            AssertGuid<IList<WwwFormUrlDecoderEntry>>("1d9ba3f5-b997-5a7d-82c4-7857ecbf3a42");
+            AssertGuid<IList<Deferral>>("a3c9b753-57ad-537f-9626-4ae5785473d4");
+            AssertGuid<IList<DateTimeOffset>>("94390dc5-e442-5870-88b6-007e232f902c");
+            AssertGuid<IList<Point>>("c0d513a9-ec4a-5a5d-b6d5-b707defdb9f7");
         }
     }
 }
diff --git a/src/Tests/UnitTest/TestComponentCSharp_Tests.cs b/src/Tests/UnitTest/TestComponentCSharp_Tests.cs
@@ -2276,8 +2276,32 @@ internal class ManagedType { }
         public void CCWOfListOfManagedType()
         {
             using var ccw = ComWrappersSupport.CreateCCWForObject(new List<ManagedType>());
-            using var qiResult = ccw.As(GuidGenerator.GetIID(typeof(global::System.Collections.Generic.IEnumerable<object>).GetHelperType()));
-        }
+            using var qiResult = ccw.As(GuidGenerator.GetIID(typeof(global::System.Collections.Generic.IEnumerable<object>).GetHelperType()));
+        }
+
+        internal class ManagedType2 : List<ManagedType2> { }
+
+        internal class ManagedType3 : List<ManagedType3>, IDisposable
+        {
+            public void Dispose()
+            {
+            }
+        }
+
+        [Fact]
+        public void CCWOfListOfManagedType2()
+        {
+            using var ccw = ComWrappersSupport.CreateCCWForObject(new ManagedType2());
+            var qiResult = ccw.As(GuidGenerator.GetIID(typeof(global::System.Collections.Generic.IEnumerable<object>).GetHelperType()));
+        }
+
+        [Fact]
+        public void CCWOfListOfManagedType3()
+        {
+            using var ccw = ComWrappersSupport.CreateCCWForObject(new ManagedType3());
+            var qiResult = ccw.As(GuidGenerator.GetIID(typeof(global::System.Collections.Generic.IEnumerable<object>).GetHelperType()));
+            var qiResult2 = ccw.As(GuidGenerator.GetIID(typeof(global::System.Collections.Generic.IEnumerable<IDisposable>).GetHelperType()));
+        }
 
         [Fact]
         public void WeakReferenceOfManagedObject()

diff --git a/src/WinRT.Runtime/ComWrappersSupport.cs b/src/WinRT.Runtime/ComWrappersSupport.cs
@@ -222,7 +222,7 @@ internal static List<ComInterfaceEntry> GetInterfaceTableEntries(
                     }
 
                     if (iface.IsConstructedGenericType
-                        && Projections.TryGetCompatibleWindowsRuntimeTypesForVariantType(iface, out var compatibleIfaces))
+                        && Projections.TryGetCompatibleWindowsRuntimeTypesForVariantType(iface, null, out var compatibleIfaces))
                     {
                         foreach (var compatibleIface in compatibleIfaces)
                         {

diff --git a/src/WinRT.Runtime/GuidGenerator.cs b/src/WinRT.Runtime/GuidGenerator.cs
@@ -96,7 +96,10 @@ public static string GetSignature(
                 }
             }
 
-            type = type.IsInterface ? (type.GetAuthoringMetadataType() ?? type) : type;
+            // For authoring interfaces, we use the metadata type to get the guid.
+            // For built-in system interfaces that are custom type mapped, we use the helper type to get the guid.
+            // For others, either the type itself or the helper type has the same guid and can be used.
+            type = type.IsInterface ? (type.GetAuthoringMetadataType() ?? helperType ?? type) : type;
 
             if (type.IsGenericType)
             {

diff --git a/src/WinRT.Runtime/Projections.cs b/src/WinRT.Runtime/Projections.cs
@@ -340,7 +340,7 @@ public static bool TryGetCompatibleWindowsRuntimeTypeForVariantType(Type type, o
             return true;
         }
 
-        private static HashSet<Type> GetCompatibleTypes(Type type)
+        private static HashSet<Type> GetCompatibleTypes(Type type, Stack<Type> typeStack)
         {
             HashSet<Type> compatibleTypes = new HashSet<Type>();
 
@@ -352,7 +352,7 @@ private static HashSet<Type> GetCompatibleTypes(Type type)
                 }
 
                 if (iface.IsConstructedGenericType
-                    && TryGetCompatibleWindowsRuntimeTypesForVariantType(iface, out var compatibleIfaces))
+                    && TryGetCompatibleWindowsRuntimeTypesForVariantType(iface, typeStack, out var compatibleIfaces))
                 {
                     compatibleTypes.UnionWith(compatibleIfaces);
                 }
@@ -411,7 +411,7 @@ void GetAllPossibleTypeCombinationsCore(List<Type> accum, Stack<Type> stack, IEn
             }
         }
 
-        internal static bool TryGetCompatibleWindowsRuntimeTypesForVariantType(Type type, out IEnumerable<Type> compatibleTypes)
+        internal static bool TryGetCompatibleWindowsRuntimeTypesForVariantType(Type type, Stack<Type> typeStack, out IEnumerable<Type> compatibleTypes)
         {
             compatibleTypes = null;
             if (!type.IsConstructedGenericType)
@@ -426,6 +426,19 @@ internal static bool TryGetCompatibleWindowsRuntimeTypesForVariantType(Type type
                 return false;
             }
 
+            if (typeStack == null)
+            {
+                typeStack = new Stack<Type>();
+            }
+            else
+            {
+                if (typeStack.Contains(type))
+                {
+                    return false;
+                }
+            }
+            typeStack.Push(type);
+
             var genericConstraints = definition.GetGenericArguments();
             var genericArguments = type.GetGenericArguments();
             List<List<Type>> compatibleTypesPerGeneric = new List<List<Type>>();
@@ -441,17 +454,19 @@ internal static bool TryGetCompatibleWindowsRuntimeTypesForVariantType(Type type
                 }
                 else if (!argumentCovariantObject)
                 {
+                    typeStack.Pop();
                     return false;
                 }
 
                 if (argumentCovariantObject)
                 {
-                    compatibleTypesForGeneric.AddRange(GetCompatibleTypes(genericArguments[i]));
+                    compatibleTypesForGeneric.AddRange(GetCompatibleTypes(genericArguments[i], typeStack));
                 }
 
                 compatibleTypesPerGeneric.Add(compatibleTypesForGeneric);
             }
 
+            typeStack.Pop();
             compatibleTypes = GetAllPossibleTypeCombinations(compatibleTypesPerGeneric, definition);
             return true;
         }