Handle generic params of manually projected types (#120)

* Handle generic params of manually projected types

* Update ts files

Author: dunhor

jswinrt/jswinrt/MetadataTypes.cpp

@@ -528,7 +528,23 @@ static void handle_generic_instantiation(projection_data& data, generic_instanti
         if ((typeDef.TypeName() == "IReference`1"sv) || (typeDef.TypeName() == "IReferenceArray`1"sv) ||
             (typeDef.TypeName() == "IAsyncActionWithProgress`1"sv) || (typeDef.TypeName() == "IAsyncOperation`1"sv) ||
             (typeDef.TypeName() == "IAsyncOperationWithProgress`2"sv))
+        {
+            // All of these types are manually projected as they are handled specially in JS. Therefore we won't get the
+            // chance to enumerate function arguments/return types below. All of the generic params for these types are
+            // visible to JS, so just go ahead and enumerate them.
+            auto stack = inst.stack();
+            for (auto&& arg : inst.signature().GenericArgs())
+            {
+                resolve_type(arg, stack,
+                    overloaded{
+                        [&](const GenericTypeInstSig& sig, const generic_param_stack& newStack, bool) {
+                            handle_generic_instantiation(data, generic_instantiation(sig, newStack));
+                        },
+                        [&](auto&&, bool) {},
+                    });
+            }
             return;
+        }
     }
 
     // First check to see if we've handled this type before

tests/RnWinRTTests/AsyncTests.js

@@ -15,6 +15,7 @@ export function makeAsyncTestScenarios(pThis) {
         new TestScenario('Test::CountDoubleAsync', runAsyncOperationWithProgressTest.bind(pThis)),
         new TestScenario('Test::ThrowAsyncException', runAsyncActionWithException.bind(pThis)),
         new TestScenario('Async await', runAsyncAwaitTest.bind(pThis)),
+        new TestScenario('Test::GetObjectsAsync', runGetObjectsTest.bind(pThis)),
     ];
 }
 
@@ -255,3 +256,17 @@ function runAsyncAwaitTest(scenario) {
         }
     });
 }
+
+function runGetObjectsTest(scenario) {
+    this.runAsync(scenario, async (resolve, reject) => {
+        try
+        {
+            var result = await TestComponent.Test.getObjectsAsync();
+            assert.equal(42, result[0].magicValue);
+
+            resolve();
+        } catch (err) {
+            reject(err);
+        }
+    });
+}

tests/RnWinRTTests/windows/TestComponent/Test.cpp

@@ -1571,11 +1571,18 @@ namespace winrt::TestComponent::implementation
         throw std::invalid_argument("test");
     }
 
-    Windows::Foundation::IAsyncOperation<int32_t> Test::ImmediateReturnAsync(int32_t value)
+    IAsyncOperation<int32_t> Test::ImmediateReturnAsync(int32_t value)
     {
         co_return value;
     }
 
+    IAsyncOperation<IVectorView<ITestInterface>> Test::GetObjectsAsync()
+    {
+        std::vector<ITestInterface> result;
+        result.push_back(winrt::make_self<TestObject>(1).as<ITestInterface>());
+        co_return winrt::single_threaded_vector(std::move(result)).as<IVectorView<ITestInterface>>();
+    }
+
     bool Test::BoolProperty()
     {
         return m_boolProperty;

tests/RnWinRTTests/windows/TestComponent/Test.h

@@ -5,7 +5,7 @@
 
 namespace winrt::TestComponent::implementation
 {
-    struct TestObject : TestObjectT<TestObject>
+    struct TestObject : TestObjectT<TestObject, ITestInterface>
     {
         TestObject(int32_t val) : m_value(val)
         {
@@ -16,6 +16,11 @@ namespace winrt::TestComponent::implementation
             return m_value;
         }
 
+        int32_t MagicValue()
+        {
+            return 42;
+        }
+
     private:
         int32_t m_value;
     };
@@ -376,6 +381,9 @@ namespace winrt::TestComponent::implementation
         static Windows::Foundation::IAsyncOperationWithProgress<int32_t, int32_t> CountDoubleAsync(int32_t value);
         static Windows::Foundation::IAsyncAction ThrowAsyncException();
         static Windows::Foundation::IAsyncOperation<int32_t> ImmediateReturnAsync(int32_t value);
+        static Windows::Foundation::IAsyncOperation<
+            Windows::Foundation::Collections::IVectorView<TestComponent::ITestInterface>>
+        GetObjectsAsync();
 
         bool BoolProperty();
         void BoolProperty(bool value);

tests/RnWinRTTests/windows/TestComponent/TestComponent.idl

@@ -69,6 +69,12 @@ namespace TestComponent
         Int32 Value{ get; };
     }
 
+    [contract(TestContract, 1)]
+    interface ITestInterface
+    {
+        Int32 MagicValue { get; }; // 42
+    }
+
     // Delegates
     delegate Boolean BoolDelegate(Boolean value);
     delegate Char CharDelegate(Char value);
@@ -581,6 +587,9 @@ namespace TestComponent
         void RaiseCompositeStructEvent(CompositeType value);
         void RaiseRefEvent(Windows.Foundation.IReference<Int32> value);
         void RaiseObjectEvent(TestObject value);
+
+        // Used to validate the fix to https://github.com/microsoft/jswinrt/issues/119
+        static Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<ITestInterface> > GetObjectsAsync();
     }
 
     [contract(TestContract, 1)]

tests/TestArtifacts/TestComponent.d.ts

@@ -58,6 +58,10 @@ declare namespace TestComponent {
         public overloadedHierarchyBaseMethod(param1: string, param2: string): string;
     }
 
+    interface ITestInterface {
+        readonly magicValue: number;
+    }
+
     type InterwovenDelegate = (inBool: boolean, inNumeric: number, inArray: number[]) => { outBool: boolean; outNumeric: number; outArray: number[]; fillArray: number[]; returnValue: number };
 
     type NumericArrayDelegate = (values: number[]) => { subset: number[]; outValue: number[]; returnValue: number[] };
@@ -435,6 +439,7 @@ declare namespace TestComponent {
         public static countDoubleAsync(value: number): Windows.Foundation.WinRTPromise<number, number>;
         public static throwAsyncException(): Windows.Foundation.WinRTPromise<void, void>;
         public static immediateReturnAsync(value: number): Windows.Foundation.WinRTPromise<number, void>;
+        public static getObjectsAsync(): Windows.Foundation.WinRTPromise<Windows.Foundation.Collections.IVectorView<TestComponent.ITestInterface>, void>;
         public addEventListener(type: "booleventhandler", listener: Windows.Foundation.TypedEventHandler<TestComponent.Test, boolean>): void;
         public removeEventListener(type: "booleventhandler", listener: Windows.Foundation.TypedEventHandler<TestComponent.Test, boolean>): void;
         public addEventListener(type: "chareventhandler", listener: Windows.Foundation.TypedEventHandler<TestComponent.Test, string>): void;