Worked around compiler bugs and fixed extension property writing.

tristanlabelle · Mar 21, 2024 · f682fcd · f682fcd
1 parent 423c934
commit f682fcd
Show file tree

Hide file tree

Showing 8 changed files with 28 additions and 12 deletions.
diff --git a/Generator/Sources/SwiftWinRT/Writing/InterfaceImplementation.swift b/Generator/Sources/SwiftWinRT/Writing/InterfaceImplementation.swift
@@ -46,10 +46,9 @@ fileprivate func writeInterfacePropertyImplementation(
         _ property: Property, typeGenericArgs: [TypeNode], classDefinition: ClassDefinition?,
         documentation: Bool, overridable: Bool, static: Bool, thisPointer: ThisPointer,
         projection: SwiftProjection, to writer: SwiftTypeDefinitionWriter) throws {
-    if `static` {
-        // Instance properties come from interfaces for which we generate extensions
-        // with non-throwing properties. Static properties are implemented directly.
-        assert(typeGenericArgs.isEmpty) // True for classes
+    if try property.definingType.hasAttribute(ExclusiveToAttribute.self) {
+        // The property is exclusive to this class so it doesn't come
+        // from an interface that would an extension property.
         // public static var myProperty: MyPropertyType { ... }
         try writeNonthrowingPropertyImplementation(
             property: property, static: `static`, projection: projection, to: writer)

diff --git a/Generator/Sources/SwiftWinRT/Writing/SecondaryInterfaces.swift b/Generator/Sources/SwiftWinRT/Writing/SecondaryInterfaces.swift
@@ -36,8 +36,16 @@ internal enum SecondaryInterfaces {
             try writer.writeBracedBlock("try \(storedPropertyName).\(SupportModule.comLazyReference_getInterop)") { writer in
                 if let staticOf {
                     let activatableId = try WinRTTypeName.from(type: staticOf.bindType()).description
-                    writer.writeStatement("try WindowsRuntime.getActivationFactory("
-                        + "activatableId: \"\(activatableId)\", id: \(abiStructType).iid)")
+                    if interfaceName == "IActivationFactory" {
+                        // Workaround a compiler bug where the compiler doesn't see the SWRT_IActivationFactory extension.
+                        writer.writeStatement("try WindowsRuntime.getActivationFactory(\n"
+                            + "activatableId: \"\(activatableId)\",\n"
+                            + "id: WindowsRuntime.IActivationFactoryProjection.interfaceID)")
+                    } else {
+                        writer.writeStatement("try WindowsRuntime.getActivationFactory(\n"
+                            + "activatableId: \"\(activatableId)\",\n"
+                            + "id: \(abiStructType).iid)")
+                    }
                 }
                 else {
                     let qiMethodName = composable ? "_queryInnerInterface" : "_queryInterface"

diff --git a/InteropTests/Tests/PropertyTests.swift b/InteropTests/Tests/PropertyTests.swift
@@ -32,12 +32,12 @@ class PropertyTests: WinRTTestCase {
         }
 
         Int32Global.getSet = 0
-        assertGet(expected: 0)
+        try assertGet(expected: 0)
 
         Int32Global.getSet = 1
-        assertGet(expected: 1)
+        try assertGet(expected: 1)
 
         try Int32Global._getSet(2)
-        assertGet(expected: 2)
+        try assertGet(expected: 2)
     }
 }
diff --git a/InteropTests/WinRTComponent/Int32Wrapper.h b/InteropTests/WinRTComponent/Int32Wrapper.h
@@ -28,8 +28,13 @@ namespace winrt::WinRTComponent::implementation
         static int32_t _value;
     };
 }
+
 namespace winrt::WinRTComponent::factory_implementation
 {
+    struct Int32Wrapper : Int32WrapperT<Int32Wrapper, implementation::Int32Wrapper>
+    {
+    };
+
     struct Int32Global : Int32GlobalT<Int32Global, implementation::Int32Global>
     {
     };

diff --git a/InteropTests/WinRTComponent/Int32Wrapper.idl b/InteropTests/WinRTComponent/Int32Wrapper.idl
@@ -2,6 +2,7 @@ namespace WinRTComponent
 {
     runtimeclass Int32Wrapper
     {
+        Int32Wrapper();
         Int32 GetSet;
         Int32 GetOnly { get; };
     };

diff --git a/Support/Sources/COM/COMInterop.swift b/Support/Sources/COM/COMInterop.swift
@@ -13,7 +13,8 @@ public protocol COMIUnknownStruct {
 
 /// Wraps a COM interface pointer and exposes projected versions of its methods.
 /// This struct is extended with methods for each COM interface it wraps.
-public struct COMInterop<Interface> where Interface: COMIUnknownStruct {
+// Should require COMIUnknownStruct but we run into compiler bugs.
+public struct COMInterop<Interface> /* where Interface: COMIUnknownStruct */ {
     public let this: UnsafeMutablePointer<Interface>
 
     public init(_ pointer: UnsafeMutablePointer<Interface>) {

diff --git a/Support/Sources/COM/COMLazyReference.swift b/Support/Sources/COM/COMLazyReference.swift
@@ -1,6 +1,7 @@
 /// Lazily initialized reference to a COM object.
 /// Essentially an Optional<COMReference<Interface>> without language support.
-public struct COMLazyReference<Interface: COMIUnknownStruct>: ~Copyable {
+// Should require COMIUnknownStruct but we run into compiler bugs.
+public struct COMLazyReference<Interface>: ~Copyable /* where Interface: COMIUnknownStruct */ {
     private var pointer: UnsafeMutablePointer<Interface>?
 
     public init() {

diff --git a/Support/Sources/COM/COMReference.swift b/Support/Sources/COM/COMReference.swift
@@ -1,7 +1,8 @@
 import WindowsRuntime_ABI
 
 /// Holds a strong reference to a COM object, like a C++ smart pointer.
-public struct COMReference<Interface: COMIUnknownStruct>: ~Copyable {
+// Should require COMIUnknownStruct but we run into compiler bugs.
+public struct COMReference<Interface>: ~Copyable /* where Interface: COMIUnknownStruct */ {
     public var pointer: UnsafeMutablePointer<Interface>
 
     public init(transferringRef pointer: UnsafeMutablePointer<Interface>) {