Added WeakReference<T> to ease consuming IWeakReferenceSource.

InteropTests/Tests/WeakReferenceTests.swift

@@ -0,0 +1,38 @@
+import XCTest
+import WindowsRuntime
+import WinRTComponent
+
+class WeakReferenceTests: WinRTTestCase {
+    func testNulledWhenUnreferencedFromSwift() throws {
+        var target: MinimalClass! = try MinimalClass()
+        let weakReference = try WeakReference<MinimalClassProjection>(target)
+        XCTAssertNotNil(try weakReference.resolve())
+        target = nil
+        XCTAssertNil(try weakReference.resolve())
+    }
+
+    func testNulledWhenUnreferencedFromWinRT() throws {
+        var target: MinimalClass! = try MinimalClass()
+        let strongReferencer = try StrongReferencer(target)
+        let weakReference = try WeakReference<MinimalClassProjection>(target)
+        target = nil
+
+        XCTAssertNotNil(try strongReferencer._target())
+        XCTAssertNotNil(try weakReference.resolve())
+
+        try strongReferencer.clear()
+
+        XCTAssertNil(try NullResult.catch(strongReferencer._target()))
+        XCTAssertNil(try weakReference.resolve())
+    }
+
+    func testThroughIWeakReferenceSource() throws {
+        var target: MinimalClass! = try MinimalClass()
+        var weakReferenceSource: IWeakReferenceSource! = try target.queryInterface(IWeakReferenceSourceProjection.self)
+        let weakReference = try weakReferenceSource.getWeakReference()
+        XCTAssertNotNil(try weakReference.resolve())
+        target = nil
+        weakReferenceSource = nil
+        XCTAssertNil(try weakReference.resolve())
+    }
+}

InteropTests/WinRTComponent/StrongReferencer.cpp

@@ -0,0 +1,19 @@
+#include "pch.h"
+#include "StrongReferencer.h"
+#include "StrongReferencer.g.cpp"
+
+namespace winrt::WinRTComponent::implementation
+{
+    StrongReferencer::StrongReferencer(winrt::Windows::Foundation::IInspectable const& target)
+    {
+        this->target = target;
+    }
+    winrt::Windows::Foundation::IInspectable StrongReferencer::Target()
+    {
+        return target;
+    }
+    void StrongReferencer::Clear()
+    {
+        target = nullptr;
+    }
+}

InteropTests/WinRTComponent/StrongReferencer.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "StrongReferencer.g.h"
+
+namespace winrt::WinRTComponent::implementation
+{
+    struct StrongReferencer : StrongReferencerT<StrongReferencer>
+    {
+        StrongReferencer(winrt::Windows::Foundation::IInspectable const& target);
+        winrt::Windows::Foundation::IInspectable Target();
+        void Clear();
+
+    private:
+        winrt::Windows::Foundation::IInspectable target;
+    };
+}
+namespace winrt::WinRTComponent::factory_implementation
+{
+    struct StrongReferencer : StrongReferencerT<StrongReferencer, implementation::StrongReferencer>
+    {
+    };
+}

InteropTests/WinRTComponent/StrongReferencer.idl

@@ -0,0 +1,9 @@
+namespace WinRTComponent
+{
+    runtimeclass StrongReferencer
+    {
+        StrongReferencer(Object target);
+        Object Target { get; };
+        void Clear();
+    }
+}

InteropTests/WinRTComponent/WinRTComponent.vcxproj

@@ -166,6 +166,9 @@
     <ClInclude Include="Strings.h">
       <DependentUpon>Strings.idl</DependentUpon>
     </ClInclude>
+    <ClInclude Include="StrongReferencer.h">
+      <DependentUpon>StrongReferencer.idl</DependentUpon>
+    </ClInclude>
     <ClInclude Include="Structs.h">
       <DependentUpon>Structs.idl</DependentUpon>
     </ClInclude>
@@ -234,6 +237,9 @@
     <ClCompile Include="Strings.cpp">
       <DependentUpon>Strings.idl</DependentUpon>
     </ClCompile>
+    <ClCompile Include="StrongReferencer.cpp">
+      <DependentUpon>StrongReferencer.idl</DependentUpon>
+    </ClCompile>
     <ClCompile Include="Structs.cpp">
       <DependentUpon>Structs.idl</DependentUpon>
     </ClCompile>
@@ -261,6 +267,7 @@
     <Midl Include="ReferenceBoxing.idl" />
     <Midl Include="ReturnArgument.idl" />
     <Midl Include="Strings.idl" />
+    <Midl Include="StrongReferencer.idl" />
     <Midl Include="Structs.idl" />
     <Midl Include="WeakReferencer.idl" />
   </ItemGroup>

Support/Sources/WindowsRuntime/WeakReference.swift

@@ -0,0 +1,26 @@
+import COM
+import WindowsRuntime_ABI
+
+/// A weak reference to a WinRT object.
+public final class WeakReference<Projection: WinRTReferenceTypeProjection> {
+    private var weakReference: COMReference<WindowsRuntime_ABI.SWRT_IWeakReference>
+
+    public init(_ target: Projection.SwiftObject) throws {
+        guard let targetInspectable = target as? IInspectable else { throw HResult.Error.invalidArg }
+        let source = try targetInspectable._queryInterface(WindowsRuntime_ABI.SWRT_IWeakReferenceSource.iid)
+            .reinterpret(to: WindowsRuntime_ABI.SWRT_IWeakReferenceSource.self)
+        var weakReference: UnsafeMutablePointer<WindowsRuntime_ABI.SWRT_IWeakReference>?
+        try WinRTError.throwIfFailed(source.pointer.pointee.VirtualTable.pointee.GetWeakReference(source.pointer, &weakReference))
+        guard let weakReference else { throw HResult.Error.fail }
+        self.weakReference = .init(transferringRef: weakReference)
+    }
+
+    public func resolve() throws -> Projection.SwiftObject? {
+        var inspectableTarget: UnsafeMutablePointer<WindowsRuntime_ABI.SWRT_IInspectable>? = nil
+        var iid = GUIDProjection.toABI(Projection.interfaceID)
+        try WinRTError.throwIfFailed(weakReference.pointer.pointee.VirtualTable.pointee.Resolve(
+            weakReference.pointer, &iid, &inspectableTarget))
+        var target = Projection.COMPointer(OpaquePointer(inspectableTarget))
+        return Projection.toSwift(consuming: &target)
+    }
+}

Support/Sources/WindowsRuntime/WinRTExport.swift

@@ -19,13 +19,13 @@ open class WinRTExport<Projection: WinRTInterfaceProjection>
             case IWeakReferenceSourceProjection.interfaceID where Self.implementIWeakReferenceSource:
                 let export = createSecondaryExport(
                     projection: IWeakReferenceSourceProjection.self,
-                    implementation: WeakReferenceSource(target: self))
+                    implementation: ExportedWeakReferenceSource(target: self))
                 return .init(addingRef: export.unknownPointer)
             case WindowsFoundation_IStringableProjection.interfaceID where Self.implementIStringable:
                 if let customStringConvertible = self as? any CustomStringConvertible {
                     let export = createSecondaryExport(
                         projection: WindowsFoundation_IStringableProjection.self,
-                        implementation: Stringable(target: customStringConvertible))
+                        implementation: ExportedStringable(target: customStringConvertible))
                     return .init(addingRef: export.unknownPointer)
                 }
                 break
@@ -68,23 +68,23 @@ fileprivate final class WinRTWrappingExport<Projection: COMTwoWayProjection>: CO
     }
 }
 
-fileprivate class Stringable: WinRTExport<WindowsFoundation_IStringableProjection>, WindowsFoundation_IStringableProtocol {
+fileprivate class ExportedStringable: WinRTExport<WindowsFoundation_IStringableProjection>, WindowsFoundation_IStringableProtocol {
     private let target: any CustomStringConvertible
     init(target: any CustomStringConvertible) { self.target = target }
     func toString() throws -> String { target.description }
 }
 
-fileprivate class WeakReference: COMExport<IWeakReferenceProjection>, IWeakReferenceProtocol {
+fileprivate class ExportedWeakReference: COMExport<IWeakReferenceProjection>, IWeakReferenceProtocol {
     weak var target: IInspectable?
     init(target: IInspectable) { self.target = target }
     func resolve() throws -> IInspectable? { target }
 }
 
-fileprivate class WeakReferenceSource: IWeakReferenceSourceProtocol {
+fileprivate class ExportedWeakReferenceSource: IWeakReferenceSourceProtocol {
     public let target: IInspectable
     init(target: IInspectable) { self.target = target }
 
-    func getWeakReference() throws -> IWeakReference { WeakReference(target: target) }
+    func getWeakReference() throws -> IWeakReference { ExportedWeakReference(target: target) }
 
     func _queryInterface(_ id: COM.COMInterfaceID) throws -> COM.IUnknownReference {
         try target._queryInterface(id)

Support/Sources/WindowsRuntime/WinRTProjectionProtocols+extensions.swift

@@ -49,4 +49,10 @@ extension WinRTReferenceTypeProjection {
             value.pointee = try code($0)
         }
     }
+}
+
+extension WinRTDelegateProjection {
+    public static func box(_ value: SwiftValue) throws -> IInspectable {
+        ReferenceBox<Self>(value)
+    }
 }

Support/Sources/WindowsRuntime/WinRTProjectionProtocols.swift

@@ -33,11 +33,5 @@ public protocol WinRTInterfaceProjection: WinRTReferenceTypeProjection, COMTwoWa
 /// Convenience protocol for projections of WinRT delegates into Swift.
 public protocol WinRTDelegateProjection: WinRTReferenceTypeProjection, WinRTBoxableProjection, COMTwoWayProjection {}
 
-extension WinRTDelegateProjection {
-    public static func box(_ value: SwiftValue) throws -> IInspectable {
-        ReferenceBox<Self>(value)
-    }
-}
-
 /// Convenience protocol for projections of WinRT classes into Swift.
 public protocol WinRTClassProjection: WinRTReferenceTypeProjection {}