C#: Add source generator for signals as events

Changed the signal declaration signal to:

```
// The following generates a MySignal event
[Signal] public delegate void MySignalEventHandler(int param);
```

1 files changed, 39 insertions, 25 deletions

diff --git a/modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators/ExtensionMethods.cs b/modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators/ExtensionMethods.cs
index c218212f04..bac4708165 100644
--- a/modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators/ExtensionMethods.cs
+++ b/modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators/ExtensionMethods.cs
@@ -174,46 +174,60 @@ namespace Godot.SourceGenerators
         public static bool IsGodotExportAttribute(this INamedTypeSymbol symbol)
             => symbol.ToString() == GodotClasses.ExportAttr;
 
+        public static bool IsGodotSignalAttribute(this INamedTypeSymbol symbol)
+            => symbol.ToString() == GodotClasses.SignalAttr;
+
         public static bool IsGodotClassNameAttribute(this INamedTypeSymbol symbol)
             => symbol.ToString() == GodotClasses.GodotClassNameAttr;
 
         public static bool IsSystemFlagsAttribute(this INamedTypeSymbol symbol)
             => symbol.ToString() == GodotClasses.SystemFlagsAttr;
 
-        public static IEnumerable<GodotMethodData> WhereHasGodotCompatibleSignature(
-            this IEnumerable<IMethodSymbol> methods,
+        public static GodotMethodData? HasGodotCompatibleSignature(
+            this IMethodSymbol method,
             MarshalUtils.TypeCache typeCache
         )
         {
-            foreach (var method in methods)
-            {
-                if (method.IsGenericMethod)
-                    continue;
+            if (method.IsGenericMethod)
+                return null;
 
-                var retSymbol = method.ReturnType;
-                var retType = method.ReturnsVoid ?
-                    null :
-                    MarshalUtils.ConvertManagedTypeToMarshalType(method.ReturnType, typeCache);
+            var retSymbol = method.ReturnType;
+            var retType = method.ReturnsVoid ?
+                null :
+                MarshalUtils.ConvertManagedTypeToMarshalType(method.ReturnType, typeCache);
 
-                if (retType == null && !method.ReturnsVoid)
-                    continue;
+            if (retType == null && !method.ReturnsVoid)
+                return null;
 
-                var parameters = method.Parameters;
+            var parameters = method.Parameters;
 
-                var paramTypes = parameters
-                    // Currently we don't support `ref`, `out`, `in`, `ref readonly` parameters (and we never may)
-                    .Where(p => p.RefKind == RefKind.None)
-                    // Attempt to determine the variant type
-                    .Select(p => MarshalUtils.ConvertManagedTypeToMarshalType(p.Type, typeCache))
-                    // Discard parameter types that couldn't be determined (null entries)
-                    .Where(t => t != null).Cast<MarshalType>().ToImmutableArray();
+            var paramTypes = parameters
+                // Currently we don't support `ref`, `out`, `in`, `ref readonly` parameters (and we never may)
+                .Where(p => p.RefKind == RefKind.None)
+                // Attempt to determine the variant type
+                .Select(p => MarshalUtils.ConvertManagedTypeToMarshalType(p.Type, typeCache))
+                // Discard parameter types that couldn't be determined (null entries)
+                .Where(t => t != null).Cast<MarshalType>().ToImmutableArray();
 
-                // If any parameter type was incompatible, it was discarded so the length won't match
-                if (parameters.Length > paramTypes.Length)
-                    continue;
+            // If any parameter type was incompatible, it was discarded so the length won't match
+            if (parameters.Length > paramTypes.Length)
+                return null; // Ignore incompatible method
+
+            return new GodotMethodData(method, paramTypes, parameters
+                .Select(p => p.Type).ToImmutableArray(), retType, retSymbol);
+        }
+
+        public static IEnumerable<GodotMethodData> WhereHasGodotCompatibleSignature(
+            this IEnumerable<IMethodSymbol> methods,
+            MarshalUtils.TypeCache typeCache
+        )
+        {
+            foreach (var method in methods)
+            {
+                var methodData = HasGodotCompatibleSignature(method, typeCache);
 
-                yield return new GodotMethodData(method, paramTypes, parameters
-                    .Select(p => p.Type).ToImmutableArray(), retType, retSymbol);
+                if (methodData != null)
+                    yield return methodData.Value;
             }
         }