Fix scenario where generic implementation type doesn't have type fact…

…ory initialized (#1693)

src/Tests/FunctionalTests/Collections/Program.cs

@@ -146,6 +146,32 @@
  return 101;
 }
 
+// Test sccenarios where the actual implementation type of the result or its RCW factory
+// hasn't been initialized and the statically declared type is a derived generic interface.
+var enums = instance.GetEnumIterable();
+int count = 0;
+foreach (var curEnum in enums)
+{
+ count++;
+}
+
+if (count != 2)
+{
+ return 101;
+}
+
+count = 0;
+var disposableClasses = instance.GetClassIterable();
+foreach (var curr in disposableClasses)
+{
+ count++;
+}
+
+if (count != 2)
+{
+ return 101;
+}
+
 return 100;
 
 static bool SequencesEqual<T>(IEnumerable<T> x, params IEnumerable<T>[] list) => list.All((y) => x.SequenceEqual(y));

src/Tests/TestComponentCSharp/Class.cpp

@@ -1491,6 +1491,18 @@ namespace winrt::TestComponentCSharp::implementation
  _charColl = value;
  }
 
+ IIterable<EnumValue> Class::GetEnumIterable()
+ {
+ return winrt::single_threaded_vector(std::vector{ EnumValue::One, EnumValue::Two });
+ }
+
+ IIterable<TestComponentCSharp::CustomDisposableTest> Class::GetClassIterable()
+ {
+ TestComponentCSharp::CustomDisposableTest first;
+ TestComponentCSharp::CustomDisposableTest second;
+ return winrt::single_threaded_vector(std::vector{ first, second });
+ }
+
  IBindableIterable Class::BindableIterableProperty()
  {
  return _bindableIterable;

src/Tests/TestComponentCSharp/Class.h

@@ -299,6 +299,8 @@ namespace winrt::TestComponentCSharp::implementation
  Windows::Foundation::Collections::IIterable<int32_t> GetIntIterable();
  void SetIntIterable(Windows::Foundation::Collections::IIterable<int32_t> const& value);
  void SetCharIterable(Windows::Foundation::Collections::IIterable<char16_t> const& value);
+ Windows::Foundation::Collections::IIterable<TestComponentCSharp::EnumValue> GetEnumIterable();
+ Windows::Foundation::Collections::IIterable<TestComponentCSharp::CustomDisposableTest> GetClassIterable();
 
  Microsoft::UI::Xaml::Interop::IBindableIterable BindableIterableProperty();
  void BindableIterableProperty(Microsoft::UI::Xaml::Interop::IBindableIterable const& value);

src/Tests/TestComponentCSharp/TestComponentCSharp.idl

@@ -346,6 +346,8 @@ namespace TestComponentCSharp
  Windows.Foundation.Collections.IIterable<Int32> GetIntIterable();
  void SetIntIterable(Windows.Foundation.Collections.IIterable<Int32> value);
  void SetCharIterable(Windows.Foundation.Collections.IIterable<Char> value);
+ Windows.Foundation.Collections.IIterable<EnumValue> GetEnumIterable();
+ Windows.Foundation.Collections.IIterable<CustomDisposableTest> GetClassIterable();
 
  // Bindable
  Microsoft.UI.Xaml.Interop.IBindableIterable BindableIterableProperty;

src/WinRT.Runtime/ComWrappersSupport.cs

@@ -641,6 +641,24 @@ internal static Type GetRuntimeClassForTypeCreation(IInspectable inspectable, Ty
  }
  }
 
+#if NET
+ // On AOT, RCW type factories for generic interfaces are registered by the projection before it asks to create
+ // an RCW for it. But we can have scenarios where the actual implementation type is different than the statically
+ // known type and the implementation type's RCW factory hasn't been initialized. i.e. IList<object> and IEnumerable<object>
+ // where the latter is the statically known type whose RCW factory is added already but IList<object> hasn't been added.
+ // In this case, since the caller just needs a IEnumerable<object>, we fallback to the statically known type if IList
+ // isn't already added. On JIT, we can construct it at runtime.
+ if (!RuntimeFeature.IsDynamicCodeCompiled)
+ {
+ if (implementationType.IsInterface && 
+ implementationType.IsGenericType &&
+ !TypedObjectFactoryCacheForType.ContainsKey(implementationType))
+ {
+ return staticallyDeterminedType;
+ }
+ }
+#endif
+
  return implementationType;
  }