C#: Add source generator for properties and exports default values

The editor no longer needs to create temporary instances to get the
default values. The initializer values of the exported properties are
still evaluated at runtime. For example, in the following example,
`GetInitialValue()` will be called when first looks for default values:

```
[Export] int MyValue = GetInitialValue();
```

Exporting fields with a non-supported type now results in a compiler
error rather than a runtime error when the script is used.

1 files changed, 134 insertions, 14 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 9586e71d02..2179aeea88 100644
--- a/modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators/ExtensionMethods.cs
+++ b/modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators/ExtensionMethods.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
@@ -24,30 +25,55 @@ namespace Godot.SourceGenerators
                toggle != null &&
                toggle.Equals("true", StringComparison.OrdinalIgnoreCase);
 
-        private static bool InheritsFrom(this INamedTypeSymbol? symbol, string baseName)
+        public static bool InheritsFrom(this INamedTypeSymbol? symbol, string assemblyName, string typeFullName)
         {
-            if (symbol == null)
-                return false;
-
-            while (true)
+            while (symbol != null)
             {
-                if (symbol.ToString() == baseName)
+                if (symbol.ContainingAssembly.Name == assemblyName &&
+                    symbol.ToString() == typeFullName)
                 {
                     return true;
                 }
 
-                if (symbol.BaseType != null)
-                {
-                    symbol = symbol.BaseType;
-                    continue;
-                }
-
-                break;
+                symbol = symbol.BaseType;
             }
 
             return false;
         }
 
+        public static INamedTypeSymbol? GetGodotScriptNativeClass(this INamedTypeSymbol classTypeSymbol)
+        {
+            var symbol = classTypeSymbol;
+
+            while (symbol != null)
+            {
+                if (symbol.ContainingAssembly.Name == "GodotSharp")
+                    return symbol;
+
+                symbol = symbol.BaseType;
+            }
+
+            return null;
+        }
+
+        public static string? GetGodotScriptNativeClassName(this INamedTypeSymbol classTypeSymbol)
+        {
+            var nativeType = classTypeSymbol.GetGodotScriptNativeClass();
+
+            if (nativeType == null)
+                return null;
+
+            var godotClassNameAttr = nativeType.GetAttributes()
+                .FirstOrDefault(a => a.AttributeClass?.IsGodotClassNameAttribute() ?? false);
+
+            string? godotClassName = null;
+
+            if (godotClassNameAttr is { ConstructorArguments: { Length: > 0 } })
+                godotClassName = godotClassNameAttr.ConstructorArguments[0].Value?.ToString();
+
+            return godotClassName ?? nativeType.Name;
+        }
+
         private static bool IsGodotScriptClass(
             this ClassDeclarationSyntax cds, Compilation compilation,
             out INamedTypeSymbol? symbol
@@ -58,7 +84,7 @@ namespace Godot.SourceGenerators
             var classTypeSymbol = sm.GetDeclaredSymbol(cds);
 
             if (classTypeSymbol?.BaseType == null
-                || !classTypeSymbol.BaseType.InheritsFrom(GodotClasses.Object))
+                || !classTypeSymbol.BaseType.InheritsFrom("GodotSharp", GodotClasses.Object))
             {
                 symbol = null;
                 return false;
@@ -129,7 +155,101 @@ namespace Godot.SourceGenerators
         public static string FullQualifiedName(this ITypeSymbol symbol)
             => symbol.ToDisplayString(NullableFlowState.NotNull, FullyQualifiedFormatOmitGlobal);
 
+        public static string NameWithTypeParameters(this INamedTypeSymbol symbol)
+        {
+            return symbol.IsGenericType ?
+                string.Concat(symbol.Name, "<", string.Join(", ", symbol.TypeParameters), ">") :
+                symbol.Name;
+        }
+
         public static string FullQualifiedName(this INamespaceSymbol namespaceSymbol)
             => namespaceSymbol.ToDisplayString(FullyQualifiedFormatOmitGlobal);
+
+        public static string SanitizeQualifiedNameForUniqueHint(this string qualifiedName)
+            => qualifiedName
+                // AddSource() doesn't support angle brackets
+                .Replace("<", "(Of ")
+                .Replace(">", ")");
+
+        public static bool IsGodotExportAttribute(this INamedTypeSymbol symbol)
+            => symbol.ToString() == GodotClasses.ExportAttr;
+
+        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,
+            MarshalUtils.TypeCache typeCache
+        )
+        {
+            foreach (var method in methods)
+            {
+                if (method.IsGenericMethod)
+                    continue;
+
+                var retType = method.ReturnsVoid ?
+                    null :
+                    MarshalUtils.ConvertManagedTypeToMarshalType(method.ReturnType, typeCache);
+
+                if (retType == null && !method.ReturnsVoid)
+                    continue;
+
+                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();
+
+                // If any parameter type was incompatible, it was discarded so the length won't match
+                if (parameters.Length > paramTypes.Length)
+                    continue;
+
+                yield return new GodotMethodData(method, paramTypes, parameters
+                    .Select(p => p.Type).ToImmutableArray(), retType);
+            }
+        }
+
+        public static IEnumerable<GodotPropertyData> WhereIsGodotCompatibleType(
+            this IEnumerable<IPropertySymbol> properties,
+            MarshalUtils.TypeCache typeCache
+        )
+        {
+            foreach (var property in properties)
+            {
+                // Ignore properties without a getter. Godot properties must be readable.
+                if (property.IsWriteOnly)
+                    continue;
+
+                var marshalType = MarshalUtils.ConvertManagedTypeToMarshalType(property.Type, typeCache);
+
+                if (marshalType == null)
+                    continue;
+
+                yield return new GodotPropertyData(property, marshalType.Value);
+            }
+        }
+
+        public static IEnumerable<GodotFieldData> WhereIsGodotCompatibleType(
+            this IEnumerable<IFieldSymbol> fields,
+            MarshalUtils.TypeCache typeCache
+        )
+        {
+            foreach (var field in fields)
+            {
+                var marshalType = MarshalUtils.ConvertManagedTypeToMarshalType(field.Type, typeCache);
+
+                if (marshalType == null)
+                    continue;
+
+                yield return new GodotFieldData(field, marshalType.Value);
+            }
+        }
     }
 }