Make @export work with GArray and Variant values, fixes #410

Sources/SwiftGodotMacroLibrary/MacroExport.swift

@@ -39,7 +39,9 @@ public struct GodotExport: PeerMacro {
         let name = "_mproxy_set_\(varName)"
         var body: String = ""
 
-        if godotVariants [typeName] == nil {
+		if typeName == "Variant" {
+			body = "\(varName) = args [0]"
+		} else if godotVariants [typeName] == nil {
             let optBody = isOptional ? " else { \(varName) = nil }" : ""
 
             // The use of the local function dynamicCast here is such that the compiler

Sources/SwiftGodotMacroLibrary/MacroGodot.swift

@@ -107,7 +107,7 @@ class GodotMacroProcessor {
                 godotArrayElementTypeName = gArrayCollectionElementTypeName
             }
 
-            propType = godotTypeToProp (typeName: "Array")
+            propType = godotTypeToProp (typeName: "GArray")
             className = "Array[\(godotArrayElementTypeName)]"
             hintStr = godotArrayElementTypeName
         } else {
@@ -375,7 +375,7 @@ class GodotMacroProcessor {
             ctor.append (
     """
     let \(pinfo) = PropInfo (
-        propertyType: \(godotTypeToProp(typeName: "Array")),
+        propertyType: \(godotTypeToProp(typeName: "GArray")),
         propertyName: "\(varNameWithPrefix.camelCaseToSnakeCase())",
         className: StringName("\(godotArrayTypeName)"),
         hint: .arrayType,

Sources/SwiftGodotMacroLibrary/MacroSharedApi.swift

@@ -31,7 +31,7 @@ func getIdentifier (_ typeSyntax: TypeSyntax?) -> (typeName: String, generics: [
         return (typeName: identifier.name.text, generics: genericTypeNames, isOptional: opt)
     } else if let array = typeSyntax.as(ArrayTypeSyntax.self),
        let elementTypeName = array.element.as(IdentifierTypeSyntax.self)?.name.text {
-        return (typeName: "Array", generics: [elementTypeName], isOptional: opt)
+        return (typeName: "GArray", generics: [elementTypeName], isOptional: opt)
     }
     return nil
 }
@@ -146,7 +146,7 @@ func getTypeName (_ parameter: FunctionParameterSyntax) -> String? {
         parameter.isObjectCollection,
         parameter.isVariantCollection
     ].allSatisfy ({ $0 == false }) else {
-        return "Array"
+        return "GArray"
     }
     guard let typeName = parameter.type.as (IdentifierTypeSyntax.self)?.name.text else {
         return nil
@@ -164,7 +164,7 @@ var godotVariants = [
     "Double": ".float",
     "Bool": ".bool",
     "AABB": ".aabb",
-    "Array": ".array",
+    "GArray": ".array",
     "Basis": ".basis",
     "Callable": ".callable",
     "Color": ".color",

Tests/SwiftGodotMacrosTests/MacroGodotBuildTest.swift

@@ -0,0 +1,21 @@
+//
+// This file is solely here to ensure that we can compile the resulting macros,
+// which is not covered by the macro output generation.
+//
+//
+//  Created by Miguel de Icaza on 2/27/24.
+//
+
+import Foundation
+import SwiftGodot
+
+@Godot
+class Demo: Object {
+	@Export var demo: GArray = GArray()
+}
+
+@Godot
+class Demo2: Object {
+	@Export var demo: Variant = Variant()
+}
+

Tests/SwiftGodotMacrosTests/MacroGodotExportCollectionTests.swift

@@ -211,6 +211,62 @@ func _mproxy_set_greetings(args: [Variant]) -> Variant? {
 		)
 	}
 
+    func testExportGArray() {
+        assertMacroExpansion(
+"""
+@Godot
+class SomeNode: Node {
+    @Export var someArray: GArray = GArray()
+}
+""",
+            expandedSource:
+"""
+
+class SomeNode: Node {
+    var someArray: GArray = GArray()
+
+    func _mproxy_set_someArray (args: [Variant]) -> Variant? {
+    	guard let arg = args.first else {
+    		return nil
+    	}
+    	if let value = GArray (arg) {
+    		self.someArray = value
+    	} else {
+    		GD.printErr ("Unable to set `someArray` value: ", arg)
+    	}
+    	return nil
+    }
+
+    func _mproxy_get_someArray (args: [Variant]) -> Variant? {
+        return Variant (someArray)
+    }
+
+    override open class var classInitializer: Void {
+        let _ = super.classInitializer
+        return _initializeClass
+    }
+
+    private static var _initializeClass: Void = {
+        let className = StringName("SomeNode")
+        assert(ClassDB.classExists(class: className))
+        let classInfo = ClassInfo<SomeNode> (name: className)
+        let _psomeArray = PropInfo (
+            propertyType: .array,
+            propertyName: "someArray",
+            className: className,
+            hint: .none,
+            hintStr: "",
+            usage: .default)
+    	classInfo.registerMethod (name: "_mproxy_get_someArray", flags: .default, returnValue: _psomeArray, arguments: [], function: SomeNode._mproxy_get_someArray)
+    	classInfo.registerMethod (name: "_mproxy_set_someArray", flags: .default, returnValue: nil, arguments: [_psomeArray], function: SomeNode._mproxy_set_someArray)
+    	classInfo.registerProperty (_psomeArray, getter: "_mproxy_get_someArray", setter: "_mproxy_set_someArray")
+    } ()
+}
+""",
+            macros: testMacros
+        )
+    }
+
 	func testExportArrayIntGodotMacro() {
 		assertMacroExpansion(
 """