initial commit, 4.5 stable

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/AbstractGenericNode(Of T)_ScriptProperties.generated.cs

@@ -0,0 +1,49 @@
+using Godot;
+using Godot.NativeInterop;
+
+partial class AbstractGenericNode<T>
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+    /// <summary>
+    /// Cached StringNames for the properties and fields contained in this class, for fast lookup.
+    /// </summary>
+    public new class PropertyName : global::Godot.Node.PropertyName {
+        /// <summary>
+        /// Cached name for the 'MyArray' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @MyArray = "MyArray";
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool SetGodotClassPropertyValue(in godot_string_name name, in godot_variant value)
+    {
+        if (name == PropertyName.@MyArray) {
+            this.@MyArray = global::Godot.NativeInterop.VariantUtils.ConvertToArray<T>(value);
+            return true;
+        }
+        return base.SetGodotClassPropertyValue(name, value);
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool GetGodotClassPropertyValue(in godot_string_name name, out godot_variant value)
+    {
+        if (name == PropertyName.@MyArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFromArray(this.@MyArray);
+            return true;
+        }
+        return base.GetGodotClassPropertyValue(name, out value);
+    }
+    /// <summary>
+    /// Get the property information for all the properties declared in this class.
+    /// This method is used by Godot to register the available properties in the editor.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo> GetGodotPropertyList()
+    {
+        var properties = new global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo>();
+        properties.Add(new(type: (global::Godot.Variant.Type)28, name: PropertyName.@MyArray, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        return properties;
+    }
+#pragma warning restore CS0109
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/AllReadOnly_ScriptProperties.generated.cs

@@ -0,0 +1,66 @@
+using Godot;
+using Godot.NativeInterop;
+
+partial class AllReadOnly
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+    /// <summary>
+    /// Cached StringNames for the properties and fields contained in this class, for fast lookup.
+    /// </summary>
+    public new class PropertyName : global::Godot.GodotObject.PropertyName {
+        /// <summary>
+        /// Cached name for the 'ReadOnlyAutoProperty' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @ReadOnlyAutoProperty = "ReadOnlyAutoProperty";
+        /// <summary>
+        /// Cached name for the 'ReadOnlyProperty' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @ReadOnlyProperty = "ReadOnlyProperty";
+        /// <summary>
+        /// Cached name for the 'InitOnlyAutoProperty' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @InitOnlyAutoProperty = "InitOnlyAutoProperty";
+        /// <summary>
+        /// Cached name for the 'ReadOnlyField' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @ReadOnlyField = "ReadOnlyField";
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool GetGodotClassPropertyValue(in godot_string_name name, out godot_variant value)
+    {
+        if (name == PropertyName.@ReadOnlyAutoProperty) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@ReadOnlyAutoProperty);
+            return true;
+        }
+        if (name == PropertyName.@ReadOnlyProperty) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@ReadOnlyProperty);
+            return true;
+        }
+        if (name == PropertyName.@InitOnlyAutoProperty) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@InitOnlyAutoProperty);
+            return true;
+        }
+        if (name == PropertyName.@ReadOnlyField) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@ReadOnlyField);
+            return true;
+        }
+        return base.GetGodotClassPropertyValue(name, out value);
+    }
+    /// <summary>
+    /// Get the property information for all the properties declared in this class.
+    /// This method is used by Godot to register the available properties in the editor.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo> GetGodotPropertyList()
+    {
+        var properties = new global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo>();
+        properties.Add(new(type: (global::Godot.Variant.Type)4, name: PropertyName.@ReadOnlyField, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4096, exported: false));
+        properties.Add(new(type: (global::Godot.Variant.Type)4, name: PropertyName.@ReadOnlyAutoProperty, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4096, exported: false));
+        properties.Add(new(type: (global::Godot.Variant.Type)4, name: PropertyName.@ReadOnlyProperty, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4096, exported: false));
+        properties.Add(new(type: (global::Godot.Variant.Type)4, name: PropertyName.@InitOnlyAutoProperty, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4096, exported: false));
+        return properties;
+    }
+#pragma warning restore CS0109
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/AllWriteOnly_ScriptProperties.generated.cs

@@ -0,0 +1,58 @@
+using Godot;
+using Godot.NativeInterop;
+
+partial class AllWriteOnly
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+    /// <summary>
+    /// Cached StringNames for the properties and fields contained in this class, for fast lookup.
+    /// </summary>
+    public new class PropertyName : global::Godot.GodotObject.PropertyName {
+        /// <summary>
+        /// Cached name for the 'WriteOnlyProperty' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @WriteOnlyProperty = "WriteOnlyProperty";
+        /// <summary>
+        /// Cached name for the '_writeOnlyBackingField' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_writeOnlyBackingField = "_writeOnlyBackingField";
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool SetGodotClassPropertyValue(in godot_string_name name, in godot_variant value)
+    {
+        if (name == PropertyName.@WriteOnlyProperty) {
+            this.@WriteOnlyProperty = global::Godot.NativeInterop.VariantUtils.ConvertTo<bool>(value);
+            return true;
+        }
+        if (name == PropertyName.@_writeOnlyBackingField) {
+            this.@_writeOnlyBackingField = global::Godot.NativeInterop.VariantUtils.ConvertTo<bool>(value);
+            return true;
+        }
+        return base.SetGodotClassPropertyValue(name, value);
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool GetGodotClassPropertyValue(in godot_string_name name, out godot_variant value)
+    {
+        if (name == PropertyName.@_writeOnlyBackingField) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<bool>(this.@_writeOnlyBackingField);
+            return true;
+        }
+        return base.GetGodotClassPropertyValue(name, out value);
+    }
+    /// <summary>
+    /// Get the property information for all the properties declared in this class.
+    /// This method is used by Godot to register the available properties in the editor.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo> GetGodotPropertyList()
+    {
+        var properties = new global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo>();
+        properties.Add(new(type: (global::Godot.Variant.Type)1, name: PropertyName.@_writeOnlyBackingField, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4096, exported: false));
+        properties.Add(new(type: (global::Godot.Variant.Type)1, name: PropertyName.@WriteOnlyProperty, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4096, exported: false));
+        return properties;
+    }
+#pragma warning restore CS0109
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/Bar_ScriptPath.generated.cs

@@ -0,0 +1,5 @@
+using Godot;
+[ScriptPathAttribute("res://Bar.cs")]
+partial class Bar
+{
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ClassPartialModifier.GD0001.fixed.cs

@@ -0,0 +1,6 @@
+using Godot;
+
+public partial class ClassPartialModifier : Node
+{
+
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/EventSignals_ScriptSignals.generated.cs

@@ -0,0 +1,58 @@
+using Godot;
+using Godot.NativeInterop;
+
+partial class EventSignals
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+    /// <summary>
+    /// Cached StringNames for the signals contained in this class, for fast lookup.
+    /// </summary>
+    public new class SignalName : global::Godot.GodotObject.SignalName {
+        /// <summary>
+        /// Cached name for the 'MySignal' signal.
+        /// </summary>
+        public new static readonly global::Godot.StringName @MySignal = "MySignal";
+    }
+    /// <summary>
+    /// Get the signal information for all the signals declared in this class.
+    /// This method is used by Godot to register the available signals in the editor.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.List<global::Godot.Bridge.MethodInfo> GetGodotSignalList()
+    {
+        var signals = new global::System.Collections.Generic.List<global::Godot.Bridge.MethodInfo>(1);
+        signals.Add(new(name: SignalName.@MySignal, returnVal: new(type: (global::Godot.Variant.Type)0, name: "", hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)6, exported: false), flags: (global::Godot.MethodFlags)1, arguments: new() { new(type: (global::Godot.Variant.Type)4, name: "str", hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)6, exported: false), new(type: (global::Godot.Variant.Type)2, name: "num", hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)6, exported: false),  }, defaultArguments: null));
+        return signals;
+    }
+#pragma warning restore CS0109
+    private global::EventSignals.MySignalEventHandler backing_MySignal;
+    /// <inheritdoc cref="global::EventSignals.MySignalEventHandler"/>
+    public event global::EventSignals.MySignalEventHandler @MySignal {
+        add => backing_MySignal += value;
+        remove => backing_MySignal -= value;
+}
+    protected void EmitSignalMySignal(string @str, int @num)
+    {
+        EmitSignal(SignalName.MySignal, @str, @num);
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override void RaiseGodotClassSignalCallbacks(in godot_string_name signal, NativeVariantPtrArgs args)
+    {
+        if (signal == SignalName.@MySignal && args.Count == 2) {
+            backing_MySignal?.Invoke(global::Godot.NativeInterop.VariantUtils.ConvertTo<string>(args[0]), global::Godot.NativeInterop.VariantUtils.ConvertTo<int>(args[1]));
+            return;
+        }
+        base.RaiseGodotClassSignalCallbacks(signal, args);
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool HasGodotClassSignal(in godot_string_name signal)
+    {
+        if (signal == SignalName.@MySignal) {
+           return true;
+        }
+        return base.HasGodotClassSignal(signal);
+    }
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ExportDiagnostics_GD0101_ScriptPropertyDefVal.generated.cs

@@ -0,0 +1,3 @@
+partial class ExportDiagnostics_GD0101
+{
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ExportDiagnostics_GD0102_ScriptPropertyDefVal.generated.cs

@@ -0,0 +1,3 @@
+partial class ExportDiagnostics_GD0102
+{
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ExportDiagnostics_GD0103_ScriptPropertyDefVal.generated.cs

@@ -0,0 +1,3 @@
+partial class ExportDiagnostics_GD0103
+{
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ExportDiagnostics_GD0104_ScriptPropertyDefVal.generated.cs

@@ -0,0 +1,3 @@
+partial class ExportDiagnostics_GD0104
+{
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ExportDiagnostics_GD0105_ScriptPropertyDefVal.generated.cs

@@ -0,0 +1,3 @@
+partial class ExportDiagnostics_GD0105
+{
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ExportDiagnostics_GD0106_KO_ScriptPropertyDefVal.generated.cs

@@ -0,0 +1,3 @@
+partial class ExportDiagnostics_GD0106_KO
+{
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ExportDiagnostics_GD0106_OK_ScriptPropertyDefVal.generated.cs

@@ -0,0 +1,21 @@
+partial class ExportDiagnostics_GD0106_OK
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+#if TOOLS
+    /// <summary>
+    /// Get the default values for all properties declared in this class.
+    /// This method is used by Godot to determine the value that will be
+    /// used by the inspector when resetting properties.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.Dictionary<global::Godot.StringName, global::Godot.Variant> GetGodotPropertyDefaultValues()
+    {
+        var values = new global::System.Collections.Generic.Dictionary<global::Godot.StringName, global::Godot.Variant>(1);
+        int __MyProperty_default_value = default;
+        values.Add(PropertyName.@MyProperty, global::Godot.Variant.From<int>(__MyProperty_default_value));
+        return values;
+    }
+#endif // TOOLS
+#pragma warning restore CS0109
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ExportDiagnostics_GD0107_KO_ScriptPropertyDefVal.generated.cs

@@ -0,0 +1,3 @@
+partial class ExportDiagnostics_GD0107_KO
+{
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ExportDiagnostics_GD0107_OK_ScriptPropertyDefVal.generated.cs

@@ -0,0 +1,39 @@
+partial class ExportDiagnostics_GD0107_OK
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+#if TOOLS
+    /// <summary>
+    /// Get the default values for all properties declared in this class.
+    /// This method is used by Godot to determine the value that will be
+    /// used by the inspector when resetting properties.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.Dictionary<global::Godot.StringName, global::Godot.Variant> GetGodotPropertyDefaultValues()
+    {
+        var values = new global::System.Collections.Generic.Dictionary<global::Godot.StringName, global::Godot.Variant>(10);
+        global::Godot.Node __NodeProperty_default_value = default;
+        values.Add(PropertyName.@NodeProperty, global::Godot.Variant.From<global::Godot.Node>(__NodeProperty_default_value));
+        global::Godot.Node[] __SystemArrayOfNodesProperty_default_value = default;
+        values.Add(PropertyName.@SystemArrayOfNodesProperty, global::Godot.Variant.CreateFrom(__SystemArrayOfNodesProperty_default_value));
+        global::Godot.Collections.Array<global::Godot.Node> __GodotArrayOfNodesProperty_default_value = default;
+        values.Add(PropertyName.@GodotArrayOfNodesProperty, global::Godot.Variant.CreateFrom(__GodotArrayOfNodesProperty_default_value));
+        global::Godot.Collections.Dictionary<global::Godot.Node, string> __GodotDictionaryWithNodeAsKeyProperty_default_value = default;
+        values.Add(PropertyName.@GodotDictionaryWithNodeAsKeyProperty, global::Godot.Variant.CreateFrom(__GodotDictionaryWithNodeAsKeyProperty_default_value));
+        global::Godot.Collections.Dictionary<string, global::Godot.Node> __GodotDictionaryWithNodeAsValueProperty_default_value = default;
+        values.Add(PropertyName.@GodotDictionaryWithNodeAsValueProperty, global::Godot.Variant.CreateFrom(__GodotDictionaryWithNodeAsValueProperty_default_value));
+        global::Godot.Node __NodeField_default_value = default;
+        values.Add(PropertyName.@NodeField, global::Godot.Variant.From<global::Godot.Node>(__NodeField_default_value));
+        global::Godot.Node[] __SystemArrayOfNodesField_default_value = default;
+        values.Add(PropertyName.@SystemArrayOfNodesField, global::Godot.Variant.CreateFrom(__SystemArrayOfNodesField_default_value));
+        global::Godot.Collections.Array<global::Godot.Node> __GodotArrayOfNodesField_default_value = default;
+        values.Add(PropertyName.@GodotArrayOfNodesField, global::Godot.Variant.CreateFrom(__GodotArrayOfNodesField_default_value));
+        global::Godot.Collections.Dictionary<global::Godot.Node, string> __GodotDictionaryWithNodeAsKeyField_default_value = default;
+        values.Add(PropertyName.@GodotDictionaryWithNodeAsKeyField, global::Godot.Variant.CreateFrom(__GodotDictionaryWithNodeAsKeyField_default_value));
+        global::Godot.Collections.Dictionary<string, global::Godot.Node> __GodotDictionaryWithNodeAsValueField_default_value = default;
+        values.Add(PropertyName.@GodotDictionaryWithNodeAsValueField, global::Godot.Variant.CreateFrom(__GodotDictionaryWithNodeAsValueField_default_value));
+        return values;
+    }
+#endif // TOOLS
+#pragma warning restore CS0109
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ExportDiagnostics_GD0108_ScriptProperties.generated.cs

@@ -0,0 +1,38 @@
+using Godot;
+using Godot.NativeInterop;
+
+partial class ExportDiagnostics_GD0108
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+    /// <summary>
+    /// Cached StringNames for the properties and fields contained in this class, for fast lookup.
+    /// </summary>
+    public new class PropertyName : global::Godot.Node.PropertyName {
+        /// <summary>
+        /// Cached name for the 'MyButton' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @MyButton = "MyButton";
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool GetGodotClassPropertyValue(in godot_string_name name, out godot_variant value)
+    {
+        if (name == PropertyName.@MyButton) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Callable>(this.@MyButton);
+            return true;
+        }
+        return base.GetGodotClassPropertyValue(name, out value);
+    }
+    /// <summary>
+    /// Get the property information for all the properties declared in this class.
+    /// This method is used by Godot to register the available properties in the editor.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo> GetGodotPropertyList()
+    {
+        var properties = new global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo>();
+        return properties;
+    }
+#pragma warning restore CS0109
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ExportDiagnostics_GD0109_ScriptProperties.generated.cs

@@ -0,0 +1,38 @@
+using Godot;
+using Godot.NativeInterop;
+
+partial class ExportDiagnostics_GD0109
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+    /// <summary>
+    /// Cached StringNames for the properties and fields contained in this class, for fast lookup.
+    /// </summary>
+    public new class PropertyName : global::Godot.Node.PropertyName {
+        /// <summary>
+        /// Cached name for the 'MyButton' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @MyButton = "MyButton";
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool GetGodotClassPropertyValue(in godot_string_name name, out godot_variant value)
+    {
+        if (name == PropertyName.@MyButton) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Callable>(this.@MyButton);
+            return true;
+        }
+        return base.GetGodotClassPropertyValue(name, out value);
+    }
+    /// <summary>
+    /// Get the property information for all the properties declared in this class.
+    /// This method is used by Godot to register the available properties in the editor.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo> GetGodotPropertyList()
+    {
+        var properties = new global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo>();
+        return properties;
+    }
+#pragma warning restore CS0109
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ExportDiagnostics_GD0110_ScriptProperties.generated.cs

@@ -0,0 +1,38 @@
+using Godot;
+using Godot.NativeInterop;
+
+partial class ExportDiagnostics_GD0110
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+    /// <summary>
+    /// Cached StringNames for the properties and fields contained in this class, for fast lookup.
+    /// </summary>
+    public new class PropertyName : global::Godot.Node.PropertyName {
+        /// <summary>
+        /// Cached name for the 'MyButton' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @MyButton = "MyButton";
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool GetGodotClassPropertyValue(in godot_string_name name, out godot_variant value)
+    {
+        if (name == PropertyName.@MyButton) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<int>(this.@MyButton);
+            return true;
+        }
+        return base.GetGodotClassPropertyValue(name, out value);
+    }
+    /// <summary>
+    /// Get the property information for all the properties declared in this class.
+    /// This method is used by Godot to register the available properties in the editor.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo> GetGodotPropertyList()
+    {
+        var properties = new global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo>();
+        return properties;
+    }
+#pragma warning restore CS0109
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ExportDiagnostics_GD0111_ScriptProperties.generated.cs

@@ -0,0 +1,116 @@
+using Godot;
+using Godot.NativeInterop;
+
+partial class ExportDiagnostics_GD0111
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+    /// <summary>
+    /// Cached StringNames for the properties and fields contained in this class, for fast lookup.
+    /// </summary>
+    public new class PropertyName : global::Godot.Node.PropertyName {
+        /// <summary>
+        /// Cached name for the 'MyButtonGet' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @MyButtonGet = "MyButtonGet";
+        /// <summary>
+        /// Cached name for the 'MyButtonGetSet' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @MyButtonGetSet = "MyButtonGetSet";
+        /// <summary>
+        /// Cached name for the 'MyButtonGetWithBackingField' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @MyButtonGetWithBackingField = "MyButtonGetWithBackingField";
+        /// <summary>
+        /// Cached name for the 'MyButtonGetSetWithBackingField' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @MyButtonGetSetWithBackingField = "MyButtonGetSetWithBackingField";
+        /// <summary>
+        /// Cached name for the 'MyButtonOkWithCallableCreationExpression' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @MyButtonOkWithCallableCreationExpression = "MyButtonOkWithCallableCreationExpression";
+        /// <summary>
+        /// Cached name for the 'MyButtonOkWithImplicitCallableCreationExpression' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @MyButtonOkWithImplicitCallableCreationExpression = "MyButtonOkWithImplicitCallableCreationExpression";
+        /// <summary>
+        /// Cached name for the 'MyButtonOkWithCallableFromExpression' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @MyButtonOkWithCallableFromExpression = "MyButtonOkWithCallableFromExpression";
+        /// <summary>
+        /// Cached name for the '_backingField' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_backingField = "_backingField";
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool SetGodotClassPropertyValue(in godot_string_name name, in godot_variant value)
+    {
+        if (name == PropertyName.@MyButtonGetSet) {
+            this.@MyButtonGetSet = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Callable>(value);
+            return true;
+        }
+        if (name == PropertyName.@MyButtonGetSetWithBackingField) {
+            this.@MyButtonGetSetWithBackingField = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Callable>(value);
+            return true;
+        }
+        if (name == PropertyName.@_backingField) {
+            this.@_backingField = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Callable>(value);
+            return true;
+        }
+        return base.SetGodotClassPropertyValue(name, value);
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool GetGodotClassPropertyValue(in godot_string_name name, out godot_variant value)
+    {
+        if (name == PropertyName.@MyButtonGet) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Callable>(this.@MyButtonGet);
+            return true;
+        }
+        if (name == PropertyName.@MyButtonGetSet) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Callable>(this.@MyButtonGetSet);
+            return true;
+        }
+        if (name == PropertyName.@MyButtonGetWithBackingField) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Callable>(this.@MyButtonGetWithBackingField);
+            return true;
+        }
+        if (name == PropertyName.@MyButtonGetSetWithBackingField) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Callable>(this.@MyButtonGetSetWithBackingField);
+            return true;
+        }
+        if (name == PropertyName.@MyButtonOkWithCallableCreationExpression) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Callable>(this.@MyButtonOkWithCallableCreationExpression);
+            return true;
+        }
+        if (name == PropertyName.@MyButtonOkWithImplicitCallableCreationExpression) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Callable>(this.@MyButtonOkWithImplicitCallableCreationExpression);
+            return true;
+        }
+        if (name == PropertyName.@MyButtonOkWithCallableFromExpression) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Callable>(this.@MyButtonOkWithCallableFromExpression);
+            return true;
+        }
+        if (name == PropertyName.@_backingField) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Callable>(this.@_backingField);
+            return true;
+        }
+        return base.GetGodotClassPropertyValue(name, out value);
+    }
+    /// <summary>
+    /// Get the property information for all the properties declared in this class.
+    /// This method is used by Godot to register the available properties in the editor.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo> GetGodotPropertyList()
+    {
+        var properties = new global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo>();
+        properties.Add(new(type: (global::Godot.Variant.Type)25, name: PropertyName.@_backingField, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4096, exported: false));
+        properties.Add(new(type: (global::Godot.Variant.Type)25, name: PropertyName.@MyButtonOkWithCallableCreationExpression, hint: (global::Godot.PropertyHint)39, hintString: "", usage: (global::Godot.PropertyUsageFlags)4, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)25, name: PropertyName.@MyButtonOkWithImplicitCallableCreationExpression, hint: (global::Godot.PropertyHint)39, hintString: "", usage: (global::Godot.PropertyUsageFlags)4, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)25, name: PropertyName.@MyButtonOkWithCallableFromExpression, hint: (global::Godot.PropertyHint)39, hintString: "", usage: (global::Godot.PropertyUsageFlags)4, exported: true));
+        return properties;
+    }
+#pragma warning restore CS0109
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ExportedComplexStrings_ScriptPropertyDefVal.generated.cs

@@ -0,0 +1,29 @@
+partial class ExportedComplexStrings
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+#if TOOLS
+    /// <summary>
+    /// Get the default values for all properties declared in this class.
+    /// This method is used by Godot to determine the value that will be
+    /// used by the inspector when resetting properties.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.Dictionary<global::Godot.StringName, global::Godot.Variant> GetGodotPropertyDefaultValues()
+    {
+        var values = new global::System.Collections.Generic.Dictionary<global::Godot.StringName, global::Godot.Variant>(5);
+        string __PropertyInterpolated1_default_value = $"The quick brown fox jumps over {(global::Godot.GD.VarToStr($"the lazy {(global::Godot.Engine.GetVersionInfo())} do"))}g.";
+        values.Add(PropertyName.@PropertyInterpolated1, global::Godot.Variant.From<string>(__PropertyInterpolated1_default_value));
+        string ___fieldInterpolated1_default_value = $"The quick brown fox jumps over ({(global::Godot.Engine.GetVersionInfo())})";
+        values.Add(PropertyName.@_fieldInterpolated1, global::Godot.Variant.From<string>(___fieldInterpolated1_default_value));
+        string ___fieldInterpolated2_default_value = $"The quick brown fox jumps over ({(global::Godot.Engine.GetVersionInfo()["major"]),0:G}) the lazy dog.";
+        values.Add(PropertyName.@_fieldInterpolated2, global::Godot.Variant.From<string>(___fieldInterpolated2_default_value));
+        string ___fieldInterpolated3_default_value = $"{(((int)global::Godot.Engine.GetVersionInfo()["major"])  * -1    * -1):G} the lazy dog.";
+        values.Add(PropertyName.@_fieldInterpolated3, global::Godot.Variant.From<string>(___fieldInterpolated3_default_value));
+        string ___fieldInterpolated4_default_value = $"{(":::fff,,}<,<}},,}]")}";
+        values.Add(PropertyName.@_fieldInterpolated4, global::Godot.Variant.From<string>(___fieldInterpolated4_default_value));
+        return values;
+    }
+#endif // TOOLS
+#pragma warning restore CS0109
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ExportedFields_ScriptProperties.generated.cs

@@ -0,0 +1,816 @@
+using Godot;
+using Godot.NativeInterop;
+
+partial class ExportedFields
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+    /// <summary>
+    /// Cached StringNames for the properties and fields contained in this class, for fast lookup.
+    /// </summary>
+    public new class PropertyName : global::Godot.GodotObject.PropertyName {
+        /// <summary>
+        /// Cached name for the '_fieldBoolean' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldBoolean = "_fieldBoolean";
+        /// <summary>
+        /// Cached name for the '_fieldChar' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldChar = "_fieldChar";
+        /// <summary>
+        /// Cached name for the '_fieldSByte' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldSByte = "_fieldSByte";
+        /// <summary>
+        /// Cached name for the '_fieldInt16' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldInt16 = "_fieldInt16";
+        /// <summary>
+        /// Cached name for the '_fieldInt32' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldInt32 = "_fieldInt32";
+        /// <summary>
+        /// Cached name for the '_fieldInt64' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldInt64 = "_fieldInt64";
+        /// <summary>
+        /// Cached name for the '_fieldByte' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldByte = "_fieldByte";
+        /// <summary>
+        /// Cached name for the '_fieldUInt16' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldUInt16 = "_fieldUInt16";
+        /// <summary>
+        /// Cached name for the '_fieldUInt32' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldUInt32 = "_fieldUInt32";
+        /// <summary>
+        /// Cached name for the '_fieldUInt64' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldUInt64 = "_fieldUInt64";
+        /// <summary>
+        /// Cached name for the '_fieldSingle' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldSingle = "_fieldSingle";
+        /// <summary>
+        /// Cached name for the '_fieldDouble' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldDouble = "_fieldDouble";
+        /// <summary>
+        /// Cached name for the '_fieldString' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldString = "_fieldString";
+        /// <summary>
+        /// Cached name for the '_fieldVector2' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldVector2 = "_fieldVector2";
+        /// <summary>
+        /// Cached name for the '_fieldVector2I' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldVector2I = "_fieldVector2I";
+        /// <summary>
+        /// Cached name for the '_fieldRect2' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldRect2 = "_fieldRect2";
+        /// <summary>
+        /// Cached name for the '_fieldRect2I' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldRect2I = "_fieldRect2I";
+        /// <summary>
+        /// Cached name for the '_fieldTransform2D' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldTransform2D = "_fieldTransform2D";
+        /// <summary>
+        /// Cached name for the '_fieldVector3' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldVector3 = "_fieldVector3";
+        /// <summary>
+        /// Cached name for the '_fieldVector3I' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldVector3I = "_fieldVector3I";
+        /// <summary>
+        /// Cached name for the '_fieldBasis' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldBasis = "_fieldBasis";
+        /// <summary>
+        /// Cached name for the '_fieldQuaternion' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldQuaternion = "_fieldQuaternion";
+        /// <summary>
+        /// Cached name for the '_fieldTransform3D' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldTransform3D = "_fieldTransform3D";
+        /// <summary>
+        /// Cached name for the '_fieldVector4' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldVector4 = "_fieldVector4";
+        /// <summary>
+        /// Cached name for the '_fieldVector4I' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldVector4I = "_fieldVector4I";
+        /// <summary>
+        /// Cached name for the '_fieldProjection' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldProjection = "_fieldProjection";
+        /// <summary>
+        /// Cached name for the '_fieldAabb' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldAabb = "_fieldAabb";
+        /// <summary>
+        /// Cached name for the '_fieldColor' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldColor = "_fieldColor";
+        /// <summary>
+        /// Cached name for the '_fieldPlane' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldPlane = "_fieldPlane";
+        /// <summary>
+        /// Cached name for the '_fieldCallable' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldCallable = "_fieldCallable";
+        /// <summary>
+        /// Cached name for the '_fieldSignal' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldSignal = "_fieldSignal";
+        /// <summary>
+        /// Cached name for the '_fieldEnum' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldEnum = "_fieldEnum";
+        /// <summary>
+        /// Cached name for the '_fieldFlagsEnum' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldFlagsEnum = "_fieldFlagsEnum";
+        /// <summary>
+        /// Cached name for the '_fieldByteArray' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldByteArray = "_fieldByteArray";
+        /// <summary>
+        /// Cached name for the '_fieldInt32Array' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldInt32Array = "_fieldInt32Array";
+        /// <summary>
+        /// Cached name for the '_fieldInt64Array' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldInt64Array = "_fieldInt64Array";
+        /// <summary>
+        /// Cached name for the '_fieldSingleArray' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldSingleArray = "_fieldSingleArray";
+        /// <summary>
+        /// Cached name for the '_fieldDoubleArray' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldDoubleArray = "_fieldDoubleArray";
+        /// <summary>
+        /// Cached name for the '_fieldStringArray' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldStringArray = "_fieldStringArray";
+        /// <summary>
+        /// Cached name for the '_fieldStringArrayEnum' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldStringArrayEnum = "_fieldStringArrayEnum";
+        /// <summary>
+        /// Cached name for the '_fieldVector2Array' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldVector2Array = "_fieldVector2Array";
+        /// <summary>
+        /// Cached name for the '_fieldVector3Array' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldVector3Array = "_fieldVector3Array";
+        /// <summary>
+        /// Cached name for the '_fieldColorArray' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldColorArray = "_fieldColorArray";
+        /// <summary>
+        /// Cached name for the '_fieldGodotObjectOrDerivedArray' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldGodotObjectOrDerivedArray = "_fieldGodotObjectOrDerivedArray";
+        /// <summary>
+        /// Cached name for the '_fieldStringNameArray' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldStringNameArray = "_fieldStringNameArray";
+        /// <summary>
+        /// Cached name for the '_fieldNodePathArray' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldNodePathArray = "_fieldNodePathArray";
+        /// <summary>
+        /// Cached name for the '_fieldRidArray' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldRidArray = "_fieldRidArray";
+        /// <summary>
+        /// Cached name for the '_fieldEmptyInt32Array' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldEmptyInt32Array = "_fieldEmptyInt32Array";
+        /// <summary>
+        /// Cached name for the '_fieldArrayFromList' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldArrayFromList = "_fieldArrayFromList";
+        /// <summary>
+        /// Cached name for the '_fieldVariant' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldVariant = "_fieldVariant";
+        /// <summary>
+        /// Cached name for the '_fieldGodotObjectOrDerived' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldGodotObjectOrDerived = "_fieldGodotObjectOrDerived";
+        /// <summary>
+        /// Cached name for the '_fieldGodotResourceTexture' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldGodotResourceTexture = "_fieldGodotResourceTexture";
+        /// <summary>
+        /// Cached name for the '_fieldStringName' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldStringName = "_fieldStringName";
+        /// <summary>
+        /// Cached name for the '_fieldNodePath' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldNodePath = "_fieldNodePath";
+        /// <summary>
+        /// Cached name for the '_fieldRid' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldRid = "_fieldRid";
+        /// <summary>
+        /// Cached name for the '_fieldGodotDictionary' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldGodotDictionary = "_fieldGodotDictionary";
+        /// <summary>
+        /// Cached name for the '_fieldGodotArray' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldGodotArray = "_fieldGodotArray";
+        /// <summary>
+        /// Cached name for the '_fieldGodotGenericDictionary' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldGodotGenericDictionary = "_fieldGodotGenericDictionary";
+        /// <summary>
+        /// Cached name for the '_fieldGodotGenericArray' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldGodotGenericArray = "_fieldGodotGenericArray";
+        /// <summary>
+        /// Cached name for the '_fieldEmptyInt64Array' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fieldEmptyInt64Array = "_fieldEmptyInt64Array";
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool SetGodotClassPropertyValue(in godot_string_name name, in godot_variant value)
+    {
+        if (name == PropertyName.@_fieldBoolean) {
+            this.@_fieldBoolean = global::Godot.NativeInterop.VariantUtils.ConvertTo<bool>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldChar) {
+            this.@_fieldChar = global::Godot.NativeInterop.VariantUtils.ConvertTo<char>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldSByte) {
+            this.@_fieldSByte = global::Godot.NativeInterop.VariantUtils.ConvertTo<sbyte>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldInt16) {
+            this.@_fieldInt16 = global::Godot.NativeInterop.VariantUtils.ConvertTo<short>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldInt32) {
+            this.@_fieldInt32 = global::Godot.NativeInterop.VariantUtils.ConvertTo<int>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldInt64) {
+            this.@_fieldInt64 = global::Godot.NativeInterop.VariantUtils.ConvertTo<long>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldByte) {
+            this.@_fieldByte = global::Godot.NativeInterop.VariantUtils.ConvertTo<byte>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldUInt16) {
+            this.@_fieldUInt16 = global::Godot.NativeInterop.VariantUtils.ConvertTo<ushort>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldUInt32) {
+            this.@_fieldUInt32 = global::Godot.NativeInterop.VariantUtils.ConvertTo<uint>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldUInt64) {
+            this.@_fieldUInt64 = global::Godot.NativeInterop.VariantUtils.ConvertTo<ulong>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldSingle) {
+            this.@_fieldSingle = global::Godot.NativeInterop.VariantUtils.ConvertTo<float>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldDouble) {
+            this.@_fieldDouble = global::Godot.NativeInterop.VariantUtils.ConvertTo<double>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldString) {
+            this.@_fieldString = global::Godot.NativeInterop.VariantUtils.ConvertTo<string>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldVector2) {
+            this.@_fieldVector2 = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Vector2>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldVector2I) {
+            this.@_fieldVector2I = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Vector2I>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldRect2) {
+            this.@_fieldRect2 = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Rect2>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldRect2I) {
+            this.@_fieldRect2I = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Rect2I>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldTransform2D) {
+            this.@_fieldTransform2D = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Transform2D>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldVector3) {
+            this.@_fieldVector3 = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Vector3>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldVector3I) {
+            this.@_fieldVector3I = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Vector3I>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldBasis) {
+            this.@_fieldBasis = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Basis>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldQuaternion) {
+            this.@_fieldQuaternion = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Quaternion>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldTransform3D) {
+            this.@_fieldTransform3D = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Transform3D>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldVector4) {
+            this.@_fieldVector4 = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Vector4>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldVector4I) {
+            this.@_fieldVector4I = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Vector4I>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldProjection) {
+            this.@_fieldProjection = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Projection>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldAabb) {
+            this.@_fieldAabb = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Aabb>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldColor) {
+            this.@_fieldColor = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Color>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldPlane) {
+            this.@_fieldPlane = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Plane>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldCallable) {
+            this.@_fieldCallable = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Callable>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldSignal) {
+            this.@_fieldSignal = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Signal>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldEnum) {
+            this.@_fieldEnum = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::ExportedFields.MyEnum>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldFlagsEnum) {
+            this.@_fieldFlagsEnum = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::ExportedFields.MyFlagsEnum>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldByteArray) {
+            this.@_fieldByteArray = global::Godot.NativeInterop.VariantUtils.ConvertTo<byte[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldInt32Array) {
+            this.@_fieldInt32Array = global::Godot.NativeInterop.VariantUtils.ConvertTo<int[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldInt64Array) {
+            this.@_fieldInt64Array = global::Godot.NativeInterop.VariantUtils.ConvertTo<long[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldSingleArray) {
+            this.@_fieldSingleArray = global::Godot.NativeInterop.VariantUtils.ConvertTo<float[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldDoubleArray) {
+            this.@_fieldDoubleArray = global::Godot.NativeInterop.VariantUtils.ConvertTo<double[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldStringArray) {
+            this.@_fieldStringArray = global::Godot.NativeInterop.VariantUtils.ConvertTo<string[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldStringArrayEnum) {
+            this.@_fieldStringArrayEnum = global::Godot.NativeInterop.VariantUtils.ConvertTo<string[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldVector2Array) {
+            this.@_fieldVector2Array = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Vector2[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldVector3Array) {
+            this.@_fieldVector3Array = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Vector3[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldColorArray) {
+            this.@_fieldColorArray = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Color[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldGodotObjectOrDerivedArray) {
+            this.@_fieldGodotObjectOrDerivedArray = global::Godot.NativeInterop.VariantUtils.ConvertToSystemArrayOfGodotObject<global::Godot.GodotObject>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldStringNameArray) {
+            this.@_fieldStringNameArray = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.StringName[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldNodePathArray) {
+            this.@_fieldNodePathArray = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.NodePath[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldRidArray) {
+            this.@_fieldRidArray = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Rid[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldEmptyInt32Array) {
+            this.@_fieldEmptyInt32Array = global::Godot.NativeInterop.VariantUtils.ConvertTo<int[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldArrayFromList) {
+            this.@_fieldArrayFromList = global::Godot.NativeInterop.VariantUtils.ConvertTo<int[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldVariant) {
+            this.@_fieldVariant = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Variant>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldGodotObjectOrDerived) {
+            this.@_fieldGodotObjectOrDerived = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.GodotObject>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldGodotResourceTexture) {
+            this.@_fieldGodotResourceTexture = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Texture>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldStringName) {
+            this.@_fieldStringName = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.StringName>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldNodePath) {
+            this.@_fieldNodePath = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.NodePath>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldRid) {
+            this.@_fieldRid = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Rid>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldGodotDictionary) {
+            this.@_fieldGodotDictionary = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Collections.Dictionary>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldGodotArray) {
+            this.@_fieldGodotArray = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Collections.Array>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldGodotGenericDictionary) {
+            this.@_fieldGodotGenericDictionary = global::Godot.NativeInterop.VariantUtils.ConvertToDictionary<string, bool>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldGodotGenericArray) {
+            this.@_fieldGodotGenericArray = global::Godot.NativeInterop.VariantUtils.ConvertToArray<int>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fieldEmptyInt64Array) {
+            this.@_fieldEmptyInt64Array = global::Godot.NativeInterop.VariantUtils.ConvertTo<long[]>(value);
+            return true;
+        }
+        return base.SetGodotClassPropertyValue(name, value);
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool GetGodotClassPropertyValue(in godot_string_name name, out godot_variant value)
+    {
+        if (name == PropertyName.@_fieldBoolean) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<bool>(this.@_fieldBoolean);
+            return true;
+        }
+        if (name == PropertyName.@_fieldChar) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<char>(this.@_fieldChar);
+            return true;
+        }
+        if (name == PropertyName.@_fieldSByte) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<sbyte>(this.@_fieldSByte);
+            return true;
+        }
+        if (name == PropertyName.@_fieldInt16) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<short>(this.@_fieldInt16);
+            return true;
+        }
+        if (name == PropertyName.@_fieldInt32) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<int>(this.@_fieldInt32);
+            return true;
+        }
+        if (name == PropertyName.@_fieldInt64) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<long>(this.@_fieldInt64);
+            return true;
+        }
+        if (name == PropertyName.@_fieldByte) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<byte>(this.@_fieldByte);
+            return true;
+        }
+        if (name == PropertyName.@_fieldUInt16) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<ushort>(this.@_fieldUInt16);
+            return true;
+        }
+        if (name == PropertyName.@_fieldUInt32) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<uint>(this.@_fieldUInt32);
+            return true;
+        }
+        if (name == PropertyName.@_fieldUInt64) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<ulong>(this.@_fieldUInt64);
+            return true;
+        }
+        if (name == PropertyName.@_fieldSingle) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<float>(this.@_fieldSingle);
+            return true;
+        }
+        if (name == PropertyName.@_fieldDouble) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<double>(this.@_fieldDouble);
+            return true;
+        }
+        if (name == PropertyName.@_fieldString) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@_fieldString);
+            return true;
+        }
+        if (name == PropertyName.@_fieldVector2) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Vector2>(this.@_fieldVector2);
+            return true;
+        }
+        if (name == PropertyName.@_fieldVector2I) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Vector2I>(this.@_fieldVector2I);
+            return true;
+        }
+        if (name == PropertyName.@_fieldRect2) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Rect2>(this.@_fieldRect2);
+            return true;
+        }
+        if (name == PropertyName.@_fieldRect2I) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Rect2I>(this.@_fieldRect2I);
+            return true;
+        }
+        if (name == PropertyName.@_fieldTransform2D) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Transform2D>(this.@_fieldTransform2D);
+            return true;
+        }
+        if (name == PropertyName.@_fieldVector3) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Vector3>(this.@_fieldVector3);
+            return true;
+        }
+        if (name == PropertyName.@_fieldVector3I) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Vector3I>(this.@_fieldVector3I);
+            return true;
+        }
+        if (name == PropertyName.@_fieldBasis) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Basis>(this.@_fieldBasis);
+            return true;
+        }
+        if (name == PropertyName.@_fieldQuaternion) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Quaternion>(this.@_fieldQuaternion);
+            return true;
+        }
+        if (name == PropertyName.@_fieldTransform3D) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Transform3D>(this.@_fieldTransform3D);
+            return true;
+        }
+        if (name == PropertyName.@_fieldVector4) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Vector4>(this.@_fieldVector4);
+            return true;
+        }
+        if (name == PropertyName.@_fieldVector4I) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Vector4I>(this.@_fieldVector4I);
+            return true;
+        }
+        if (name == PropertyName.@_fieldProjection) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Projection>(this.@_fieldProjection);
+            return true;
+        }
+        if (name == PropertyName.@_fieldAabb) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Aabb>(this.@_fieldAabb);
+            return true;
+        }
+        if (name == PropertyName.@_fieldColor) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Color>(this.@_fieldColor);
+            return true;
+        }
+        if (name == PropertyName.@_fieldPlane) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Plane>(this.@_fieldPlane);
+            return true;
+        }
+        if (name == PropertyName.@_fieldCallable) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Callable>(this.@_fieldCallable);
+            return true;
+        }
+        if (name == PropertyName.@_fieldSignal) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Signal>(this.@_fieldSignal);
+            return true;
+        }
+        if (name == PropertyName.@_fieldEnum) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::ExportedFields.MyEnum>(this.@_fieldEnum);
+            return true;
+        }
+        if (name == PropertyName.@_fieldFlagsEnum) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::ExportedFields.MyFlagsEnum>(this.@_fieldFlagsEnum);
+            return true;
+        }
+        if (name == PropertyName.@_fieldByteArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<byte[]>(this.@_fieldByteArray);
+            return true;
+        }
+        if (name == PropertyName.@_fieldInt32Array) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<int[]>(this.@_fieldInt32Array);
+            return true;
+        }
+        if (name == PropertyName.@_fieldInt64Array) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<long[]>(this.@_fieldInt64Array);
+            return true;
+        }
+        if (name == PropertyName.@_fieldSingleArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<float[]>(this.@_fieldSingleArray);
+            return true;
+        }
+        if (name == PropertyName.@_fieldDoubleArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<double[]>(this.@_fieldDoubleArray);
+            return true;
+        }
+        if (name == PropertyName.@_fieldStringArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string[]>(this.@_fieldStringArray);
+            return true;
+        }
+        if (name == PropertyName.@_fieldStringArrayEnum) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string[]>(this.@_fieldStringArrayEnum);
+            return true;
+        }
+        if (name == PropertyName.@_fieldVector2Array) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Vector2[]>(this.@_fieldVector2Array);
+            return true;
+        }
+        if (name == PropertyName.@_fieldVector3Array) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Vector3[]>(this.@_fieldVector3Array);
+            return true;
+        }
+        if (name == PropertyName.@_fieldColorArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Color[]>(this.@_fieldColorArray);
+            return true;
+        }
+        if (name == PropertyName.@_fieldGodotObjectOrDerivedArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFromSystemArrayOfGodotObject(this.@_fieldGodotObjectOrDerivedArray);
+            return true;
+        }
+        if (name == PropertyName.@_fieldStringNameArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.StringName[]>(this.@_fieldStringNameArray);
+            return true;
+        }
+        if (name == PropertyName.@_fieldNodePathArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.NodePath[]>(this.@_fieldNodePathArray);
+            return true;
+        }
+        if (name == PropertyName.@_fieldRidArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Rid[]>(this.@_fieldRidArray);
+            return true;
+        }
+        if (name == PropertyName.@_fieldEmptyInt32Array) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<int[]>(this.@_fieldEmptyInt32Array);
+            return true;
+        }
+        if (name == PropertyName.@_fieldArrayFromList) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<int[]>(this.@_fieldArrayFromList);
+            return true;
+        }
+        if (name == PropertyName.@_fieldVariant) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Variant>(this.@_fieldVariant);
+            return true;
+        }
+        if (name == PropertyName.@_fieldGodotObjectOrDerived) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.GodotObject>(this.@_fieldGodotObjectOrDerived);
+            return true;
+        }
+        if (name == PropertyName.@_fieldGodotResourceTexture) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Texture>(this.@_fieldGodotResourceTexture);
+            return true;
+        }
+        if (name == PropertyName.@_fieldStringName) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.StringName>(this.@_fieldStringName);
+            return true;
+        }
+        if (name == PropertyName.@_fieldNodePath) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.NodePath>(this.@_fieldNodePath);
+            return true;
+        }
+        if (name == PropertyName.@_fieldRid) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Rid>(this.@_fieldRid);
+            return true;
+        }
+        if (name == PropertyName.@_fieldGodotDictionary) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Collections.Dictionary>(this.@_fieldGodotDictionary);
+            return true;
+        }
+        if (name == PropertyName.@_fieldGodotArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Collections.Array>(this.@_fieldGodotArray);
+            return true;
+        }
+        if (name == PropertyName.@_fieldGodotGenericDictionary) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFromDictionary(this.@_fieldGodotGenericDictionary);
+            return true;
+        }
+        if (name == PropertyName.@_fieldGodotGenericArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFromArray(this.@_fieldGodotGenericArray);
+            return true;
+        }
+        if (name == PropertyName.@_fieldEmptyInt64Array) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<long[]>(this.@_fieldEmptyInt64Array);
+            return true;
+        }
+        return base.GetGodotClassPropertyValue(name, out value);
+    }
+    /// <summary>
+    /// Get the property information for all the properties declared in this class.
+    /// This method is used by Godot to register the available properties in the editor.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo> GetGodotPropertyList()
+    {
+        var properties = new global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo>();
+        properties.Add(new(type: (global::Godot.Variant.Type)1, name: PropertyName.@_fieldBoolean, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@_fieldChar, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@_fieldSByte, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@_fieldInt16, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@_fieldInt32, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@_fieldInt64, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@_fieldByte, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@_fieldUInt16, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@_fieldUInt32, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@_fieldUInt64, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)3, name: PropertyName.@_fieldSingle, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)3, name: PropertyName.@_fieldDouble, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)4, name: PropertyName.@_fieldString, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)5, name: PropertyName.@_fieldVector2, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)6, name: PropertyName.@_fieldVector2I, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)7, name: PropertyName.@_fieldRect2, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)8, name: PropertyName.@_fieldRect2I, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)11, name: PropertyName.@_fieldTransform2D, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)9, name: PropertyName.@_fieldVector3, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)10, name: PropertyName.@_fieldVector3I, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)17, name: PropertyName.@_fieldBasis, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)15, name: PropertyName.@_fieldQuaternion, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)18, name: PropertyName.@_fieldTransform3D, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)12, name: PropertyName.@_fieldVector4, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)13, name: PropertyName.@_fieldVector4I, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)19, name: PropertyName.@_fieldProjection, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)16, name: PropertyName.@_fieldAabb, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)20, name: PropertyName.@_fieldColor, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)14, name: PropertyName.@_fieldPlane, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)25, name: PropertyName.@_fieldCallable, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)26, name: PropertyName.@_fieldSignal, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@_fieldEnum, hint: (global::Godot.PropertyHint)2, hintString: "A,B,C", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@_fieldFlagsEnum, hint: (global::Godot.PropertyHint)6, hintString: "A:0,B:1,C:2", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)29, name: PropertyName.@_fieldByteArray, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)30, name: PropertyName.@_fieldInt32Array, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)31, name: PropertyName.@_fieldInt64Array, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)32, name: PropertyName.@_fieldSingleArray, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)33, name: PropertyName.@_fieldDoubleArray, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)34, name: PropertyName.@_fieldStringArray, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)34, name: PropertyName.@_fieldStringArrayEnum, hint: (global::Godot.PropertyHint)23, hintString: "4/2:A,B,C", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)35, name: PropertyName.@_fieldVector2Array, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)36, name: PropertyName.@_fieldVector3Array, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)37, name: PropertyName.@_fieldColorArray, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)28, name: PropertyName.@_fieldGodotObjectOrDerivedArray, hint: (global::Godot.PropertyHint)23, hintString: "24/0:", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)28, name: PropertyName.@_fieldStringNameArray, hint: (global::Godot.PropertyHint)23, hintString: "21/0:", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)28, name: PropertyName.@_fieldNodePathArray, hint: (global::Godot.PropertyHint)23, hintString: "22/0:", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)28, name: PropertyName.@_fieldRidArray, hint: (global::Godot.PropertyHint)23, hintString: "23/0:", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)30, name: PropertyName.@_fieldEmptyInt32Array, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)30, name: PropertyName.@_fieldArrayFromList, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)0, name: PropertyName.@_fieldVariant, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)135174, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)24, name: PropertyName.@_fieldGodotObjectOrDerived, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)24, name: PropertyName.@_fieldGodotResourceTexture, hint: (global::Godot.PropertyHint)17, hintString: "Texture", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)21, name: PropertyName.@_fieldStringName, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)22, name: PropertyName.@_fieldNodePath, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)23, name: PropertyName.@_fieldRid, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)27, name: PropertyName.@_fieldGodotDictionary, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)28, name: PropertyName.@_fieldGodotArray, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)27, name: PropertyName.@_fieldGodotGenericDictionary, hint: (global::Godot.PropertyHint)23, hintString: "4/0:;1/0:", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)28, name: PropertyName.@_fieldGodotGenericArray, hint: (global::Godot.PropertyHint)23, hintString: "2/0:", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)31, name: PropertyName.@_fieldEmptyInt64Array, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        return properties;
+    }
+#pragma warning restore CS0109
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ExportedFields_ScriptPropertyDefVal.generated.cs

@@ -0,0 +1,139 @@
+partial class ExportedFields
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+#if TOOLS
+    /// <summary>
+    /// Get the default values for all properties declared in this class.
+    /// This method is used by Godot to determine the value that will be
+    /// used by the inspector when resetting properties.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.Dictionary<global::Godot.StringName, global::Godot.Variant> GetGodotPropertyDefaultValues()
+    {
+        var values = new global::System.Collections.Generic.Dictionary<global::Godot.StringName, global::Godot.Variant>(60);
+        bool ___fieldBoolean_default_value = true;
+        values.Add(PropertyName.@_fieldBoolean, global::Godot.Variant.From<bool>(___fieldBoolean_default_value));
+        char ___fieldChar_default_value = 'f';
+        values.Add(PropertyName.@_fieldChar, global::Godot.Variant.From<char>(___fieldChar_default_value));
+        sbyte ___fieldSByte_default_value = 10;
+        values.Add(PropertyName.@_fieldSByte, global::Godot.Variant.From<sbyte>(___fieldSByte_default_value));
+        short ___fieldInt16_default_value = 10;
+        values.Add(PropertyName.@_fieldInt16, global::Godot.Variant.From<short>(___fieldInt16_default_value));
+        int ___fieldInt32_default_value = 10;
+        values.Add(PropertyName.@_fieldInt32, global::Godot.Variant.From<int>(___fieldInt32_default_value));
+        long ___fieldInt64_default_value = -10_000;
+        values.Add(PropertyName.@_fieldInt64, global::Godot.Variant.From<long>(___fieldInt64_default_value));
+        byte ___fieldByte_default_value = 10;
+        values.Add(PropertyName.@_fieldByte, global::Godot.Variant.From<byte>(___fieldByte_default_value));
+        ushort ___fieldUInt16_default_value = 10;
+        values.Add(PropertyName.@_fieldUInt16, global::Godot.Variant.From<ushort>(___fieldUInt16_default_value));
+        uint ___fieldUInt32_default_value = 10;
+        values.Add(PropertyName.@_fieldUInt32, global::Godot.Variant.From<uint>(___fieldUInt32_default_value));
+        ulong ___fieldUInt64_default_value = 10;
+        values.Add(PropertyName.@_fieldUInt64, global::Godot.Variant.From<ulong>(___fieldUInt64_default_value));
+        float ___fieldSingle_default_value = 10;
+        values.Add(PropertyName.@_fieldSingle, global::Godot.Variant.From<float>(___fieldSingle_default_value));
+        double ___fieldDouble_default_value = 10;
+        values.Add(PropertyName.@_fieldDouble, global::Godot.Variant.From<double>(___fieldDouble_default_value));
+        string ___fieldString_default_value = "foo";
+        values.Add(PropertyName.@_fieldString, global::Godot.Variant.From<string>(___fieldString_default_value));
+        global::Godot.Vector2 ___fieldVector2_default_value = new(10f, 10f);
+        values.Add(PropertyName.@_fieldVector2, global::Godot.Variant.From<global::Godot.Vector2>(___fieldVector2_default_value));
+        global::Godot.Vector2I ___fieldVector2I_default_value = global::Godot.Vector2I.Up;
+        values.Add(PropertyName.@_fieldVector2I, global::Godot.Variant.From<global::Godot.Vector2I>(___fieldVector2I_default_value));
+        global::Godot.Rect2 ___fieldRect2_default_value = new(new global::Godot.Vector2(10f, 10f), new global::Godot.Vector2(10f, 10f));
+        values.Add(PropertyName.@_fieldRect2, global::Godot.Variant.From<global::Godot.Rect2>(___fieldRect2_default_value));
+        global::Godot.Rect2I ___fieldRect2I_default_value = new(new global::Godot.Vector2I(10, 10), new global::Godot.Vector2I(10, 10));
+        values.Add(PropertyName.@_fieldRect2I, global::Godot.Variant.From<global::Godot.Rect2I>(___fieldRect2I_default_value));
+        global::Godot.Transform2D ___fieldTransform2D_default_value = global::Godot.Transform2D.Identity;
+        values.Add(PropertyName.@_fieldTransform2D, global::Godot.Variant.From<global::Godot.Transform2D>(___fieldTransform2D_default_value));
+        global::Godot.Vector3 ___fieldVector3_default_value = new(10f, 10f, 10f);
+        values.Add(PropertyName.@_fieldVector3, global::Godot.Variant.From<global::Godot.Vector3>(___fieldVector3_default_value));
+        global::Godot.Vector3I ___fieldVector3I_default_value = global::Godot.Vector3I.Back;
+        values.Add(PropertyName.@_fieldVector3I, global::Godot.Variant.From<global::Godot.Vector3I>(___fieldVector3I_default_value));
+        global::Godot.Basis ___fieldBasis_default_value = new global::Godot.Basis(global::Godot.Quaternion.Identity);
+        values.Add(PropertyName.@_fieldBasis, global::Godot.Variant.From<global::Godot.Basis>(___fieldBasis_default_value));
+        global::Godot.Quaternion ___fieldQuaternion_default_value = new global::Godot.Quaternion(global::Godot.Basis.Identity);
+        values.Add(PropertyName.@_fieldQuaternion, global::Godot.Variant.From<global::Godot.Quaternion>(___fieldQuaternion_default_value));
+        global::Godot.Transform3D ___fieldTransform3D_default_value = global::Godot.Transform3D.Identity;
+        values.Add(PropertyName.@_fieldTransform3D, global::Godot.Variant.From<global::Godot.Transform3D>(___fieldTransform3D_default_value));
+        global::Godot.Vector4 ___fieldVector4_default_value = new(10f, 10f, 10f, 10f);
+        values.Add(PropertyName.@_fieldVector4, global::Godot.Variant.From<global::Godot.Vector4>(___fieldVector4_default_value));
+        global::Godot.Vector4I ___fieldVector4I_default_value = global::Godot.Vector4I.One;
+        values.Add(PropertyName.@_fieldVector4I, global::Godot.Variant.From<global::Godot.Vector4I>(___fieldVector4I_default_value));
+        global::Godot.Projection ___fieldProjection_default_value = global::Godot.Projection.Identity;
+        values.Add(PropertyName.@_fieldProjection, global::Godot.Variant.From<global::Godot.Projection>(___fieldProjection_default_value));
+        global::Godot.Aabb ___fieldAabb_default_value = new global::Godot.Aabb(10f, 10f, 10f, new global::Godot.Vector3(1f, 1f, 1f));
+        values.Add(PropertyName.@_fieldAabb, global::Godot.Variant.From<global::Godot.Aabb>(___fieldAabb_default_value));
+        global::Godot.Color ___fieldColor_default_value = global::Godot.Colors.Aquamarine;
+        values.Add(PropertyName.@_fieldColor, global::Godot.Variant.From<global::Godot.Color>(___fieldColor_default_value));
+        global::Godot.Plane ___fieldPlane_default_value = global::Godot.Plane.PlaneXZ;
+        values.Add(PropertyName.@_fieldPlane, global::Godot.Variant.From<global::Godot.Plane>(___fieldPlane_default_value));
+        global::Godot.Callable ___fieldCallable_default_value = new global::Godot.Callable(global::Godot.Engine.GetMainLoop(), "_process");
+        values.Add(PropertyName.@_fieldCallable, global::Godot.Variant.From<global::Godot.Callable>(___fieldCallable_default_value));
+        global::Godot.Signal ___fieldSignal_default_value = new global::Godot.Signal(global::Godot.Engine.GetMainLoop(), "property_list_changed");
+        values.Add(PropertyName.@_fieldSignal, global::Godot.Variant.From<global::Godot.Signal>(___fieldSignal_default_value));
+        global::ExportedFields.MyEnum ___fieldEnum_default_value = global::ExportedFields.MyEnum.C;
+        values.Add(PropertyName.@_fieldEnum, global::Godot.Variant.From<global::ExportedFields.MyEnum>(___fieldEnum_default_value));
+        global::ExportedFields.MyFlagsEnum ___fieldFlagsEnum_default_value = global::ExportedFields.MyFlagsEnum.C;
+        values.Add(PropertyName.@_fieldFlagsEnum, global::Godot.Variant.From<global::ExportedFields.MyFlagsEnum>(___fieldFlagsEnum_default_value));
+        byte[] ___fieldByteArray_default_value = { 0, 1, 2, 3, 4, 5, 6  };
+        values.Add(PropertyName.@_fieldByteArray, global::Godot.Variant.From<byte[]>(___fieldByteArray_default_value));
+        int[] ___fieldInt32Array_default_value = { 0, 1, 2, 3, 4, 5, 6  };
+        values.Add(PropertyName.@_fieldInt32Array, global::Godot.Variant.From<int[]>(___fieldInt32Array_default_value));
+        long[] ___fieldInt64Array_default_value = { 0, 1, 2, 3, 4, 5, 6  };
+        values.Add(PropertyName.@_fieldInt64Array, global::Godot.Variant.From<long[]>(___fieldInt64Array_default_value));
+        float[] ___fieldSingleArray_default_value = { 0f, 1f, 2f, 3f, 4f, 5f, 6f  };
+        values.Add(PropertyName.@_fieldSingleArray, global::Godot.Variant.From<float[]>(___fieldSingleArray_default_value));
+        double[] ___fieldDoubleArray_default_value = { 0d, 1d, 2d, 3d, 4d, 5d, 6d  };
+        values.Add(PropertyName.@_fieldDoubleArray, global::Godot.Variant.From<double[]>(___fieldDoubleArray_default_value));
+        string[] ___fieldStringArray_default_value = { "foo", "bar"  };
+        values.Add(PropertyName.@_fieldStringArray, global::Godot.Variant.From<string[]>(___fieldStringArray_default_value));
+        string[] ___fieldStringArrayEnum_default_value = { "foo", "bar"  };
+        values.Add(PropertyName.@_fieldStringArrayEnum, global::Godot.Variant.From<string[]>(___fieldStringArrayEnum_default_value));
+        global::Godot.Vector2[] ___fieldVector2Array_default_value = { global::Godot.Vector2.Up, global::Godot.Vector2.Down, global::Godot.Vector2.Left, global::Godot.Vector2.Right   };
+        values.Add(PropertyName.@_fieldVector2Array, global::Godot.Variant.From<global::Godot.Vector2[]>(___fieldVector2Array_default_value));
+        global::Godot.Vector3[] ___fieldVector3Array_default_value = { global::Godot.Vector3.Up, global::Godot.Vector3.Down, global::Godot.Vector3.Left, global::Godot.Vector3.Right   };
+        values.Add(PropertyName.@_fieldVector3Array, global::Godot.Variant.From<global::Godot.Vector3[]>(___fieldVector3Array_default_value));
+        global::Godot.Color[] ___fieldColorArray_default_value = { global::Godot.Colors.Aqua, global::Godot.Colors.Aquamarine, global::Godot.Colors.Azure, global::Godot.Colors.Beige   };
+        values.Add(PropertyName.@_fieldColorArray, global::Godot.Variant.From<global::Godot.Color[]>(___fieldColorArray_default_value));
+        global::Godot.GodotObject[] ___fieldGodotObjectOrDerivedArray_default_value = { null  };
+        values.Add(PropertyName.@_fieldGodotObjectOrDerivedArray, global::Godot.Variant.CreateFrom(___fieldGodotObjectOrDerivedArray_default_value));
+        global::Godot.StringName[] ___fieldStringNameArray_default_value = { "foo", "bar"  };
+        values.Add(PropertyName.@_fieldStringNameArray, global::Godot.Variant.From<global::Godot.StringName[]>(___fieldStringNameArray_default_value));
+        global::Godot.NodePath[] ___fieldNodePathArray_default_value = { "foo", "bar"  };
+        values.Add(PropertyName.@_fieldNodePathArray, global::Godot.Variant.From<global::Godot.NodePath[]>(___fieldNodePathArray_default_value));
+        global::Godot.Rid[] ___fieldRidArray_default_value = { default, default, default  };
+        values.Add(PropertyName.@_fieldRidArray, global::Godot.Variant.From<global::Godot.Rid[]>(___fieldRidArray_default_value));
+        int[] ___fieldEmptyInt32Array_default_value = global::System.Array.Empty<int>();
+        values.Add(PropertyName.@_fieldEmptyInt32Array, global::Godot.Variant.From<int[]>(___fieldEmptyInt32Array_default_value));
+        int[] ___fieldArrayFromList_default_value = new global::System.Collections.Generic.List<int>(global::System.Array.Empty<int>()).ToArray();
+        values.Add(PropertyName.@_fieldArrayFromList, global::Godot.Variant.From<int[]>(___fieldArrayFromList_default_value));
+        global::Godot.Variant ___fieldVariant_default_value = "foo";
+        values.Add(PropertyName.@_fieldVariant, global::Godot.Variant.From<global::Godot.Variant>(___fieldVariant_default_value));
+        global::Godot.GodotObject ___fieldGodotObjectOrDerived_default_value = default;
+        values.Add(PropertyName.@_fieldGodotObjectOrDerived, global::Godot.Variant.From<global::Godot.GodotObject>(___fieldGodotObjectOrDerived_default_value));
+        global::Godot.Texture ___fieldGodotResourceTexture_default_value = default;
+        values.Add(PropertyName.@_fieldGodotResourceTexture, global::Godot.Variant.From<global::Godot.Texture>(___fieldGodotResourceTexture_default_value));
+        global::Godot.StringName ___fieldStringName_default_value = new global::Godot.StringName("foo");
+        values.Add(PropertyName.@_fieldStringName, global::Godot.Variant.From<global::Godot.StringName>(___fieldStringName_default_value));
+        global::Godot.NodePath ___fieldNodePath_default_value = new global::Godot.NodePath("foo");
+        values.Add(PropertyName.@_fieldNodePath, global::Godot.Variant.From<global::Godot.NodePath>(___fieldNodePath_default_value));
+        global::Godot.Rid ___fieldRid_default_value = default;
+        values.Add(PropertyName.@_fieldRid, global::Godot.Variant.From<global::Godot.Rid>(___fieldRid_default_value));
+        global::Godot.Collections.Dictionary ___fieldGodotDictionary_default_value = new()  { { "foo", 10  }, { global::Godot.Vector2.Up, global::Godot.Colors.Chocolate   }  };
+        values.Add(PropertyName.@_fieldGodotDictionary, global::Godot.Variant.From<global::Godot.Collections.Dictionary>(___fieldGodotDictionary_default_value));
+        global::Godot.Collections.Array ___fieldGodotArray_default_value = new()  { "foo", 10, global::Godot.Vector2.Up, global::Godot.Colors.Chocolate   };
+        values.Add(PropertyName.@_fieldGodotArray, global::Godot.Variant.From<global::Godot.Collections.Array>(___fieldGodotArray_default_value));
+        global::Godot.Collections.Dictionary<string, bool> ___fieldGodotGenericDictionary_default_value = new()  { { "foo", true  }, { "bar", false  }  };
+        values.Add(PropertyName.@_fieldGodotGenericDictionary, global::Godot.Variant.CreateFrom(___fieldGodotGenericDictionary_default_value));
+        global::Godot.Collections.Array<int> ___fieldGodotGenericArray_default_value = new()  { 0, 1, 2, 3, 4, 5, 6  };
+        values.Add(PropertyName.@_fieldGodotGenericArray, global::Godot.Variant.CreateFrom(___fieldGodotGenericArray_default_value));
+        long[] ___fieldEmptyInt64Array_default_value = global::System.Array.Empty<long>();
+        values.Add(PropertyName.@_fieldEmptyInt64Array, global::Godot.Variant.From<long[]>(___fieldEmptyInt64Array_default_value));
+        return values;
+    }
+#endif // TOOLS
+#pragma warning restore CS0109
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ExportedProperties2_ScriptPropertyDefVal.generated.cs

@@ -0,0 +1,25 @@
+partial class ExportedProperties2
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+#if TOOLS
+    /// <summary>
+    /// Get the default values for all properties declared in this class.
+    /// This method is used by Godot to determine the value that will be
+    /// used by the inspector when resetting properties.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.Dictionary<global::Godot.StringName, global::Godot.Variant> GetGodotPropertyDefaultValues()
+    {
+        var values = new global::System.Collections.Generic.Dictionary<global::Godot.StringName, global::Godot.Variant>(3);
+        int __Health_default_value = default;
+        values.Add(PropertyName.@Health, global::Godot.Variant.From<int>(__Health_default_value));
+        global::Godot.Resource __SubResource_default_value = default;
+        values.Add(PropertyName.@SubResource, global::Godot.Variant.From<global::Godot.Resource>(__SubResource_default_value));
+        string[] __Strings_default_value = default;
+        values.Add(PropertyName.@Strings, global::Godot.Variant.From<string[]>(__Strings_default_value));
+        return values;
+    }
+#endif // TOOLS
+#pragma warning restore CS0109
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ExportedProperties_ScriptProperties.generated.cs

@@ -0,0 +1,933 @@
+using Godot;
+using Godot.NativeInterop;
+
+partial class ExportedProperties
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+    /// <summary>
+    /// Cached StringNames for the properties and fields contained in this class, for fast lookup.
+    /// </summary>
+    public new class PropertyName : global::Godot.GodotObject.PropertyName {
+        /// <summary>
+        /// Cached name for the 'NotGenerateComplexLamdaProperty' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @NotGenerateComplexLamdaProperty = "NotGenerateComplexLamdaProperty";
+        /// <summary>
+        /// Cached name for the 'NotGenerateLamdaNoFieldProperty' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @NotGenerateLamdaNoFieldProperty = "NotGenerateLamdaNoFieldProperty";
+        /// <summary>
+        /// Cached name for the 'NotGenerateComplexReturnProperty' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @NotGenerateComplexReturnProperty = "NotGenerateComplexReturnProperty";
+        /// <summary>
+        /// Cached name for the 'NotGenerateReturnsProperty' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @NotGenerateReturnsProperty = "NotGenerateReturnsProperty";
+        /// <summary>
+        /// Cached name for the 'FullPropertyString' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @FullPropertyString = "FullPropertyString";
+        /// <summary>
+        /// Cached name for the 'FullPropertyString_Complex' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @FullPropertyString_Complex = "FullPropertyString_Complex";
+        /// <summary>
+        /// Cached name for the 'LamdaPropertyString' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @LamdaPropertyString = "LamdaPropertyString";
+        /// <summary>
+        /// Cached name for the 'PropertyBoolean' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyBoolean = "PropertyBoolean";
+        /// <summary>
+        /// Cached name for the 'PropertyChar' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyChar = "PropertyChar";
+        /// <summary>
+        /// Cached name for the 'PropertySByte' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertySByte = "PropertySByte";
+        /// <summary>
+        /// Cached name for the 'PropertyInt16' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyInt16 = "PropertyInt16";
+        /// <summary>
+        /// Cached name for the 'PropertyInt32' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyInt32 = "PropertyInt32";
+        /// <summary>
+        /// Cached name for the 'PropertyInt64' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyInt64 = "PropertyInt64";
+        /// <summary>
+        /// Cached name for the 'PropertyByte' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyByte = "PropertyByte";
+        /// <summary>
+        /// Cached name for the 'PropertyUInt16' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyUInt16 = "PropertyUInt16";
+        /// <summary>
+        /// Cached name for the 'PropertyUInt32' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyUInt32 = "PropertyUInt32";
+        /// <summary>
+        /// Cached name for the 'PropertyUInt64' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyUInt64 = "PropertyUInt64";
+        /// <summary>
+        /// Cached name for the 'PropertySingle' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertySingle = "PropertySingle";
+        /// <summary>
+        /// Cached name for the 'PropertyDouble' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyDouble = "PropertyDouble";
+        /// <summary>
+        /// Cached name for the 'PropertyString' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyString = "PropertyString";
+        /// <summary>
+        /// Cached name for the 'PropertyVector2' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyVector2 = "PropertyVector2";
+        /// <summary>
+        /// Cached name for the 'PropertyVector2I' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyVector2I = "PropertyVector2I";
+        /// <summary>
+        /// Cached name for the 'PropertyRect2' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyRect2 = "PropertyRect2";
+        /// <summary>
+        /// Cached name for the 'PropertyRect2I' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyRect2I = "PropertyRect2I";
+        /// <summary>
+        /// Cached name for the 'PropertyTransform2D' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyTransform2D = "PropertyTransform2D";
+        /// <summary>
+        /// Cached name for the 'PropertyVector3' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyVector3 = "PropertyVector3";
+        /// <summary>
+        /// Cached name for the 'PropertyVector3I' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyVector3I = "PropertyVector3I";
+        /// <summary>
+        /// Cached name for the 'PropertyBasis' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyBasis = "PropertyBasis";
+        /// <summary>
+        /// Cached name for the 'PropertyQuaternion' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyQuaternion = "PropertyQuaternion";
+        /// <summary>
+        /// Cached name for the 'PropertyTransform3D' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyTransform3D = "PropertyTransform3D";
+        /// <summary>
+        /// Cached name for the 'PropertyVector4' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyVector4 = "PropertyVector4";
+        /// <summary>
+        /// Cached name for the 'PropertyVector4I' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyVector4I = "PropertyVector4I";
+        /// <summary>
+        /// Cached name for the 'PropertyProjection' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyProjection = "PropertyProjection";
+        /// <summary>
+        /// Cached name for the 'PropertyAabb' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyAabb = "PropertyAabb";
+        /// <summary>
+        /// Cached name for the 'PropertyColor' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyColor = "PropertyColor";
+        /// <summary>
+        /// Cached name for the 'PropertyPlane' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyPlane = "PropertyPlane";
+        /// <summary>
+        /// Cached name for the 'PropertyCallable' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyCallable = "PropertyCallable";
+        /// <summary>
+        /// Cached name for the 'PropertySignal' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertySignal = "PropertySignal";
+        /// <summary>
+        /// Cached name for the 'PropertyEnum' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyEnum = "PropertyEnum";
+        /// <summary>
+        /// Cached name for the 'PropertyFlagsEnum' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyFlagsEnum = "PropertyFlagsEnum";
+        /// <summary>
+        /// Cached name for the 'PropertyByteArray' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyByteArray = "PropertyByteArray";
+        /// <summary>
+        /// Cached name for the 'PropertyInt32Array' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyInt32Array = "PropertyInt32Array";
+        /// <summary>
+        /// Cached name for the 'PropertyInt64Array' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyInt64Array = "PropertyInt64Array";
+        /// <summary>
+        /// Cached name for the 'PropertySingleArray' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertySingleArray = "PropertySingleArray";
+        /// <summary>
+        /// Cached name for the 'PropertyDoubleArray' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyDoubleArray = "PropertyDoubleArray";
+        /// <summary>
+        /// Cached name for the 'PropertyStringArray' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyStringArray = "PropertyStringArray";
+        /// <summary>
+        /// Cached name for the 'PropertyStringArrayEnum' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyStringArrayEnum = "PropertyStringArrayEnum";
+        /// <summary>
+        /// Cached name for the 'PropertyVector2Array' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyVector2Array = "PropertyVector2Array";
+        /// <summary>
+        /// Cached name for the 'PropertyVector3Array' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyVector3Array = "PropertyVector3Array";
+        /// <summary>
+        /// Cached name for the 'PropertyColorArray' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyColorArray = "PropertyColorArray";
+        /// <summary>
+        /// Cached name for the 'PropertyGodotObjectOrDerivedArray' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyGodotObjectOrDerivedArray = "PropertyGodotObjectOrDerivedArray";
+        /// <summary>
+        /// Cached name for the 'field_StringNameArray' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @field_StringNameArray = "field_StringNameArray";
+        /// <summary>
+        /// Cached name for the 'field_NodePathArray' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @field_NodePathArray = "field_NodePathArray";
+        /// <summary>
+        /// Cached name for the 'field_RidArray' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @field_RidArray = "field_RidArray";
+        /// <summary>
+        /// Cached name for the 'PropertyVariant' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyVariant = "PropertyVariant";
+        /// <summary>
+        /// Cached name for the 'PropertyGodotObjectOrDerived' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyGodotObjectOrDerived = "PropertyGodotObjectOrDerived";
+        /// <summary>
+        /// Cached name for the 'PropertyGodotResourceTexture' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyGodotResourceTexture = "PropertyGodotResourceTexture";
+        /// <summary>
+        /// Cached name for the 'PropertyStringName' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyStringName = "PropertyStringName";
+        /// <summary>
+        /// Cached name for the 'PropertyNodePath' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyNodePath = "PropertyNodePath";
+        /// <summary>
+        /// Cached name for the 'PropertyRid' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyRid = "PropertyRid";
+        /// <summary>
+        /// Cached name for the 'PropertyGodotDictionary' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyGodotDictionary = "PropertyGodotDictionary";
+        /// <summary>
+        /// Cached name for the 'PropertyGodotArray' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyGodotArray = "PropertyGodotArray";
+        /// <summary>
+        /// Cached name for the 'PropertyGodotGenericDictionary' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyGodotGenericDictionary = "PropertyGodotGenericDictionary";
+        /// <summary>
+        /// Cached name for the 'PropertyGodotGenericArray' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @PropertyGodotGenericArray = "PropertyGodotGenericArray";
+        /// <summary>
+        /// Cached name for the '_notGeneratePropertyString' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_notGeneratePropertyString = "_notGeneratePropertyString";
+        /// <summary>
+        /// Cached name for the '_notGeneratePropertyInt' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_notGeneratePropertyInt = "_notGeneratePropertyInt";
+        /// <summary>
+        /// Cached name for the '_fullPropertyString' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fullPropertyString = "_fullPropertyString";
+        /// <summary>
+        /// Cached name for the '_fullPropertyStringComplex' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_fullPropertyStringComplex = "_fullPropertyStringComplex";
+        /// <summary>
+        /// Cached name for the '_lamdaPropertyString' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_lamdaPropertyString = "_lamdaPropertyString";
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool SetGodotClassPropertyValue(in godot_string_name name, in godot_variant value)
+    {
+        if (name == PropertyName.@NotGenerateComplexLamdaProperty) {
+            this.@NotGenerateComplexLamdaProperty = global::Godot.NativeInterop.VariantUtils.ConvertTo<string>(value);
+            return true;
+        }
+        if (name == PropertyName.@NotGenerateLamdaNoFieldProperty) {
+            this.@NotGenerateLamdaNoFieldProperty = global::Godot.NativeInterop.VariantUtils.ConvertTo<string>(value);
+            return true;
+        }
+        if (name == PropertyName.@NotGenerateComplexReturnProperty) {
+            this.@NotGenerateComplexReturnProperty = global::Godot.NativeInterop.VariantUtils.ConvertTo<string>(value);
+            return true;
+        }
+        if (name == PropertyName.@NotGenerateReturnsProperty) {
+            this.@NotGenerateReturnsProperty = global::Godot.NativeInterop.VariantUtils.ConvertTo<string>(value);
+            return true;
+        }
+        if (name == PropertyName.@FullPropertyString) {
+            this.@FullPropertyString = global::Godot.NativeInterop.VariantUtils.ConvertTo<string>(value);
+            return true;
+        }
+        if (name == PropertyName.@FullPropertyString_Complex) {
+            this.@FullPropertyString_Complex = global::Godot.NativeInterop.VariantUtils.ConvertTo<string>(value);
+            return true;
+        }
+        if (name == PropertyName.@LamdaPropertyString) {
+            this.@LamdaPropertyString = global::Godot.NativeInterop.VariantUtils.ConvertTo<string>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyBoolean) {
+            this.@PropertyBoolean = global::Godot.NativeInterop.VariantUtils.ConvertTo<bool>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyChar) {
+            this.@PropertyChar = global::Godot.NativeInterop.VariantUtils.ConvertTo<char>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertySByte) {
+            this.@PropertySByte = global::Godot.NativeInterop.VariantUtils.ConvertTo<sbyte>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyInt16) {
+            this.@PropertyInt16 = global::Godot.NativeInterop.VariantUtils.ConvertTo<short>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyInt32) {
+            this.@PropertyInt32 = global::Godot.NativeInterop.VariantUtils.ConvertTo<int>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyInt64) {
+            this.@PropertyInt64 = global::Godot.NativeInterop.VariantUtils.ConvertTo<long>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyByte) {
+            this.@PropertyByte = global::Godot.NativeInterop.VariantUtils.ConvertTo<byte>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyUInt16) {
+            this.@PropertyUInt16 = global::Godot.NativeInterop.VariantUtils.ConvertTo<ushort>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyUInt32) {
+            this.@PropertyUInt32 = global::Godot.NativeInterop.VariantUtils.ConvertTo<uint>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyUInt64) {
+            this.@PropertyUInt64 = global::Godot.NativeInterop.VariantUtils.ConvertTo<ulong>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertySingle) {
+            this.@PropertySingle = global::Godot.NativeInterop.VariantUtils.ConvertTo<float>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyDouble) {
+            this.@PropertyDouble = global::Godot.NativeInterop.VariantUtils.ConvertTo<double>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyString) {
+            this.@PropertyString = global::Godot.NativeInterop.VariantUtils.ConvertTo<string>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyVector2) {
+            this.@PropertyVector2 = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Vector2>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyVector2I) {
+            this.@PropertyVector2I = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Vector2I>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyRect2) {
+            this.@PropertyRect2 = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Rect2>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyRect2I) {
+            this.@PropertyRect2I = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Rect2I>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyTransform2D) {
+            this.@PropertyTransform2D = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Transform2D>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyVector3) {
+            this.@PropertyVector3 = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Vector3>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyVector3I) {
+            this.@PropertyVector3I = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Vector3I>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyBasis) {
+            this.@PropertyBasis = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Basis>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyQuaternion) {
+            this.@PropertyQuaternion = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Quaternion>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyTransform3D) {
+            this.@PropertyTransform3D = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Transform3D>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyVector4) {
+            this.@PropertyVector4 = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Vector4>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyVector4I) {
+            this.@PropertyVector4I = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Vector4I>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyProjection) {
+            this.@PropertyProjection = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Projection>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyAabb) {
+            this.@PropertyAabb = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Aabb>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyColor) {
+            this.@PropertyColor = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Color>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyPlane) {
+            this.@PropertyPlane = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Plane>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyCallable) {
+            this.@PropertyCallable = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Callable>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertySignal) {
+            this.@PropertySignal = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Signal>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyEnum) {
+            this.@PropertyEnum = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::ExportedProperties.MyEnum>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyFlagsEnum) {
+            this.@PropertyFlagsEnum = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::ExportedProperties.MyFlagsEnum>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyByteArray) {
+            this.@PropertyByteArray = global::Godot.NativeInterop.VariantUtils.ConvertTo<byte[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyInt32Array) {
+            this.@PropertyInt32Array = global::Godot.NativeInterop.VariantUtils.ConvertTo<int[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyInt64Array) {
+            this.@PropertyInt64Array = global::Godot.NativeInterop.VariantUtils.ConvertTo<long[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertySingleArray) {
+            this.@PropertySingleArray = global::Godot.NativeInterop.VariantUtils.ConvertTo<float[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyDoubleArray) {
+            this.@PropertyDoubleArray = global::Godot.NativeInterop.VariantUtils.ConvertTo<double[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyStringArray) {
+            this.@PropertyStringArray = global::Godot.NativeInterop.VariantUtils.ConvertTo<string[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyStringArrayEnum) {
+            this.@PropertyStringArrayEnum = global::Godot.NativeInterop.VariantUtils.ConvertTo<string[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyVector2Array) {
+            this.@PropertyVector2Array = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Vector2[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyVector3Array) {
+            this.@PropertyVector3Array = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Vector3[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyColorArray) {
+            this.@PropertyColorArray = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Color[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyGodotObjectOrDerivedArray) {
+            this.@PropertyGodotObjectOrDerivedArray = global::Godot.NativeInterop.VariantUtils.ConvertToSystemArrayOfGodotObject<global::Godot.GodotObject>(value);
+            return true;
+        }
+        if (name == PropertyName.@field_StringNameArray) {
+            this.@field_StringNameArray = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.StringName[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@field_NodePathArray) {
+            this.@field_NodePathArray = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.NodePath[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@field_RidArray) {
+            this.@field_RidArray = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Rid[]>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyVariant) {
+            this.@PropertyVariant = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Variant>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyGodotObjectOrDerived) {
+            this.@PropertyGodotObjectOrDerived = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.GodotObject>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyGodotResourceTexture) {
+            this.@PropertyGodotResourceTexture = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Texture>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyStringName) {
+            this.@PropertyStringName = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.StringName>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyNodePath) {
+            this.@PropertyNodePath = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.NodePath>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyRid) {
+            this.@PropertyRid = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Rid>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyGodotDictionary) {
+            this.@PropertyGodotDictionary = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Collections.Dictionary>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyGodotArray) {
+            this.@PropertyGodotArray = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.Collections.Array>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyGodotGenericDictionary) {
+            this.@PropertyGodotGenericDictionary = global::Godot.NativeInterop.VariantUtils.ConvertToDictionary<string, bool>(value);
+            return true;
+        }
+        if (name == PropertyName.@PropertyGodotGenericArray) {
+            this.@PropertyGodotGenericArray = global::Godot.NativeInterop.VariantUtils.ConvertToArray<int>(value);
+            return true;
+        }
+        if (name == PropertyName.@_notGeneratePropertyString) {
+            this.@_notGeneratePropertyString = global::Godot.NativeInterop.VariantUtils.ConvertTo<string>(value);
+            return true;
+        }
+        if (name == PropertyName.@_notGeneratePropertyInt) {
+            this.@_notGeneratePropertyInt = global::Godot.NativeInterop.VariantUtils.ConvertTo<int>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fullPropertyString) {
+            this.@_fullPropertyString = global::Godot.NativeInterop.VariantUtils.ConvertTo<string>(value);
+            return true;
+        }
+        if (name == PropertyName.@_fullPropertyStringComplex) {
+            this.@_fullPropertyStringComplex = global::Godot.NativeInterop.VariantUtils.ConvertTo<string>(value);
+            return true;
+        }
+        if (name == PropertyName.@_lamdaPropertyString) {
+            this.@_lamdaPropertyString = global::Godot.NativeInterop.VariantUtils.ConvertTo<string>(value);
+            return true;
+        }
+        return base.SetGodotClassPropertyValue(name, value);
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool GetGodotClassPropertyValue(in godot_string_name name, out godot_variant value)
+    {
+        if (name == PropertyName.@NotGenerateComplexLamdaProperty) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@NotGenerateComplexLamdaProperty);
+            return true;
+        }
+        if (name == PropertyName.@NotGenerateLamdaNoFieldProperty) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@NotGenerateLamdaNoFieldProperty);
+            return true;
+        }
+        if (name == PropertyName.@NotGenerateComplexReturnProperty) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@NotGenerateComplexReturnProperty);
+            return true;
+        }
+        if (name == PropertyName.@NotGenerateReturnsProperty) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@NotGenerateReturnsProperty);
+            return true;
+        }
+        if (name == PropertyName.@FullPropertyString) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@FullPropertyString);
+            return true;
+        }
+        if (name == PropertyName.@FullPropertyString_Complex) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@FullPropertyString_Complex);
+            return true;
+        }
+        if (name == PropertyName.@LamdaPropertyString) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@LamdaPropertyString);
+            return true;
+        }
+        if (name == PropertyName.@PropertyBoolean) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<bool>(this.@PropertyBoolean);
+            return true;
+        }
+        if (name == PropertyName.@PropertyChar) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<char>(this.@PropertyChar);
+            return true;
+        }
+        if (name == PropertyName.@PropertySByte) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<sbyte>(this.@PropertySByte);
+            return true;
+        }
+        if (name == PropertyName.@PropertyInt16) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<short>(this.@PropertyInt16);
+            return true;
+        }
+        if (name == PropertyName.@PropertyInt32) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<int>(this.@PropertyInt32);
+            return true;
+        }
+        if (name == PropertyName.@PropertyInt64) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<long>(this.@PropertyInt64);
+            return true;
+        }
+        if (name == PropertyName.@PropertyByte) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<byte>(this.@PropertyByte);
+            return true;
+        }
+        if (name == PropertyName.@PropertyUInt16) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<ushort>(this.@PropertyUInt16);
+            return true;
+        }
+        if (name == PropertyName.@PropertyUInt32) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<uint>(this.@PropertyUInt32);
+            return true;
+        }
+        if (name == PropertyName.@PropertyUInt64) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<ulong>(this.@PropertyUInt64);
+            return true;
+        }
+        if (name == PropertyName.@PropertySingle) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<float>(this.@PropertySingle);
+            return true;
+        }
+        if (name == PropertyName.@PropertyDouble) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<double>(this.@PropertyDouble);
+            return true;
+        }
+        if (name == PropertyName.@PropertyString) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@PropertyString);
+            return true;
+        }
+        if (name == PropertyName.@PropertyVector2) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Vector2>(this.@PropertyVector2);
+            return true;
+        }
+        if (name == PropertyName.@PropertyVector2I) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Vector2I>(this.@PropertyVector2I);
+            return true;
+        }
+        if (name == PropertyName.@PropertyRect2) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Rect2>(this.@PropertyRect2);
+            return true;
+        }
+        if (name == PropertyName.@PropertyRect2I) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Rect2I>(this.@PropertyRect2I);
+            return true;
+        }
+        if (name == PropertyName.@PropertyTransform2D) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Transform2D>(this.@PropertyTransform2D);
+            return true;
+        }
+        if (name == PropertyName.@PropertyVector3) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Vector3>(this.@PropertyVector3);
+            return true;
+        }
+        if (name == PropertyName.@PropertyVector3I) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Vector3I>(this.@PropertyVector3I);
+            return true;
+        }
+        if (name == PropertyName.@PropertyBasis) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Basis>(this.@PropertyBasis);
+            return true;
+        }
+        if (name == PropertyName.@PropertyQuaternion) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Quaternion>(this.@PropertyQuaternion);
+            return true;
+        }
+        if (name == PropertyName.@PropertyTransform3D) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Transform3D>(this.@PropertyTransform3D);
+            return true;
+        }
+        if (name == PropertyName.@PropertyVector4) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Vector4>(this.@PropertyVector4);
+            return true;
+        }
+        if (name == PropertyName.@PropertyVector4I) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Vector4I>(this.@PropertyVector4I);
+            return true;
+        }
+        if (name == PropertyName.@PropertyProjection) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Projection>(this.@PropertyProjection);
+            return true;
+        }
+        if (name == PropertyName.@PropertyAabb) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Aabb>(this.@PropertyAabb);
+            return true;
+        }
+        if (name == PropertyName.@PropertyColor) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Color>(this.@PropertyColor);
+            return true;
+        }
+        if (name == PropertyName.@PropertyPlane) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Plane>(this.@PropertyPlane);
+            return true;
+        }
+        if (name == PropertyName.@PropertyCallable) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Callable>(this.@PropertyCallable);
+            return true;
+        }
+        if (name == PropertyName.@PropertySignal) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Signal>(this.@PropertySignal);
+            return true;
+        }
+        if (name == PropertyName.@PropertyEnum) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::ExportedProperties.MyEnum>(this.@PropertyEnum);
+            return true;
+        }
+        if (name == PropertyName.@PropertyFlagsEnum) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::ExportedProperties.MyFlagsEnum>(this.@PropertyFlagsEnum);
+            return true;
+        }
+        if (name == PropertyName.@PropertyByteArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<byte[]>(this.@PropertyByteArray);
+            return true;
+        }
+        if (name == PropertyName.@PropertyInt32Array) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<int[]>(this.@PropertyInt32Array);
+            return true;
+        }
+        if (name == PropertyName.@PropertyInt64Array) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<long[]>(this.@PropertyInt64Array);
+            return true;
+        }
+        if (name == PropertyName.@PropertySingleArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<float[]>(this.@PropertySingleArray);
+            return true;
+        }
+        if (name == PropertyName.@PropertyDoubleArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<double[]>(this.@PropertyDoubleArray);
+            return true;
+        }
+        if (name == PropertyName.@PropertyStringArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string[]>(this.@PropertyStringArray);
+            return true;
+        }
+        if (name == PropertyName.@PropertyStringArrayEnum) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string[]>(this.@PropertyStringArrayEnum);
+            return true;
+        }
+        if (name == PropertyName.@PropertyVector2Array) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Vector2[]>(this.@PropertyVector2Array);
+            return true;
+        }
+        if (name == PropertyName.@PropertyVector3Array) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Vector3[]>(this.@PropertyVector3Array);
+            return true;
+        }
+        if (name == PropertyName.@PropertyColorArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Color[]>(this.@PropertyColorArray);
+            return true;
+        }
+        if (name == PropertyName.@PropertyGodotObjectOrDerivedArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFromSystemArrayOfGodotObject(this.@PropertyGodotObjectOrDerivedArray);
+            return true;
+        }
+        if (name == PropertyName.@field_StringNameArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.StringName[]>(this.@field_StringNameArray);
+            return true;
+        }
+        if (name == PropertyName.@field_NodePathArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.NodePath[]>(this.@field_NodePathArray);
+            return true;
+        }
+        if (name == PropertyName.@field_RidArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Rid[]>(this.@field_RidArray);
+            return true;
+        }
+        if (name == PropertyName.@PropertyVariant) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Variant>(this.@PropertyVariant);
+            return true;
+        }
+        if (name == PropertyName.@PropertyGodotObjectOrDerived) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.GodotObject>(this.@PropertyGodotObjectOrDerived);
+            return true;
+        }
+        if (name == PropertyName.@PropertyGodotResourceTexture) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Texture>(this.@PropertyGodotResourceTexture);
+            return true;
+        }
+        if (name == PropertyName.@PropertyStringName) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.StringName>(this.@PropertyStringName);
+            return true;
+        }
+        if (name == PropertyName.@PropertyNodePath) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.NodePath>(this.@PropertyNodePath);
+            return true;
+        }
+        if (name == PropertyName.@PropertyRid) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Rid>(this.@PropertyRid);
+            return true;
+        }
+        if (name == PropertyName.@PropertyGodotDictionary) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Collections.Dictionary>(this.@PropertyGodotDictionary);
+            return true;
+        }
+        if (name == PropertyName.@PropertyGodotArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Collections.Array>(this.@PropertyGodotArray);
+            return true;
+        }
+        if (name == PropertyName.@PropertyGodotGenericDictionary) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFromDictionary(this.@PropertyGodotGenericDictionary);
+            return true;
+        }
+        if (name == PropertyName.@PropertyGodotGenericArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFromArray(this.@PropertyGodotGenericArray);
+            return true;
+        }
+        if (name == PropertyName.@_notGeneratePropertyString) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@_notGeneratePropertyString);
+            return true;
+        }
+        if (name == PropertyName.@_notGeneratePropertyInt) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<int>(this.@_notGeneratePropertyInt);
+            return true;
+        }
+        if (name == PropertyName.@_fullPropertyString) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@_fullPropertyString);
+            return true;
+        }
+        if (name == PropertyName.@_fullPropertyStringComplex) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@_fullPropertyStringComplex);
+            return true;
+        }
+        if (name == PropertyName.@_lamdaPropertyString) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@_lamdaPropertyString);
+            return true;
+        }
+        return base.GetGodotClassPropertyValue(name, out value);
+    }
+    /// <summary>
+    /// Get the property information for all the properties declared in this class.
+    /// This method is used by Godot to register the available properties in the editor.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo> GetGodotPropertyList()
+    {
+        var properties = new global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo>();
+        properties.Add(new(type: (global::Godot.Variant.Type)4, name: PropertyName.@_notGeneratePropertyString, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4096, exported: false));
+        properties.Add(new(type: (global::Godot.Variant.Type)4, name: PropertyName.@NotGenerateComplexLamdaProperty, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)4, name: PropertyName.@NotGenerateLamdaNoFieldProperty, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)4, name: PropertyName.@NotGenerateComplexReturnProperty, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@_notGeneratePropertyInt, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4096, exported: false));
+        properties.Add(new(type: (global::Godot.Variant.Type)4, name: PropertyName.@NotGenerateReturnsProperty, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)4, name: PropertyName.@_fullPropertyString, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4096, exported: false));
+        properties.Add(new(type: (global::Godot.Variant.Type)4, name: PropertyName.@FullPropertyString, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)4, name: PropertyName.@_fullPropertyStringComplex, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4096, exported: false));
+        properties.Add(new(type: (global::Godot.Variant.Type)4, name: PropertyName.@FullPropertyString_Complex, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)4, name: PropertyName.@_lamdaPropertyString, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4096, exported: false));
+        properties.Add(new(type: (global::Godot.Variant.Type)4, name: PropertyName.@LamdaPropertyString, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)1, name: PropertyName.@PropertyBoolean, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@PropertyChar, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@PropertySByte, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@PropertyInt16, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@PropertyInt32, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@PropertyInt64, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@PropertyByte, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@PropertyUInt16, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@PropertyUInt32, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@PropertyUInt64, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)3, name: PropertyName.@PropertySingle, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)3, name: PropertyName.@PropertyDouble, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)4, name: PropertyName.@PropertyString, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)5, name: PropertyName.@PropertyVector2, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)6, name: PropertyName.@PropertyVector2I, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)7, name: PropertyName.@PropertyRect2, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)8, name: PropertyName.@PropertyRect2I, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)11, name: PropertyName.@PropertyTransform2D, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)9, name: PropertyName.@PropertyVector3, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)10, name: PropertyName.@PropertyVector3I, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)17, name: PropertyName.@PropertyBasis, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)15, name: PropertyName.@PropertyQuaternion, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)18, name: PropertyName.@PropertyTransform3D, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)12, name: PropertyName.@PropertyVector4, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)13, name: PropertyName.@PropertyVector4I, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)19, name: PropertyName.@PropertyProjection, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)16, name: PropertyName.@PropertyAabb, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)20, name: PropertyName.@PropertyColor, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)14, name: PropertyName.@PropertyPlane, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)25, name: PropertyName.@PropertyCallable, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)26, name: PropertyName.@PropertySignal, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@PropertyEnum, hint: (global::Godot.PropertyHint)2, hintString: "A,B,C", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@PropertyFlagsEnum, hint: (global::Godot.PropertyHint)6, hintString: "A:0,B:1,C:2", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)29, name: PropertyName.@PropertyByteArray, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)30, name: PropertyName.@PropertyInt32Array, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)31, name: PropertyName.@PropertyInt64Array, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)32, name: PropertyName.@PropertySingleArray, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)33, name: PropertyName.@PropertyDoubleArray, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)34, name: PropertyName.@PropertyStringArray, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)34, name: PropertyName.@PropertyStringArrayEnum, hint: (global::Godot.PropertyHint)23, hintString: "4/2:A,B,C", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)35, name: PropertyName.@PropertyVector2Array, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)36, name: PropertyName.@PropertyVector3Array, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)37, name: PropertyName.@PropertyColorArray, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)28, name: PropertyName.@PropertyGodotObjectOrDerivedArray, hint: (global::Godot.PropertyHint)23, hintString: "24/0:", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)28, name: PropertyName.@field_StringNameArray, hint: (global::Godot.PropertyHint)23, hintString: "21/0:", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)28, name: PropertyName.@field_NodePathArray, hint: (global::Godot.PropertyHint)23, hintString: "22/0:", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)28, name: PropertyName.@field_RidArray, hint: (global::Godot.PropertyHint)23, hintString: "23/0:", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)0, name: PropertyName.@PropertyVariant, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)135174, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)24, name: PropertyName.@PropertyGodotObjectOrDerived, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)24, name: PropertyName.@PropertyGodotResourceTexture, hint: (global::Godot.PropertyHint)17, hintString: "Texture", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)21, name: PropertyName.@PropertyStringName, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)22, name: PropertyName.@PropertyNodePath, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)23, name: PropertyName.@PropertyRid, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)27, name: PropertyName.@PropertyGodotDictionary, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)28, name: PropertyName.@PropertyGodotArray, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)27, name: PropertyName.@PropertyGodotGenericDictionary, hint: (global::Godot.PropertyHint)23, hintString: "4/0:;1/0:", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)28, name: PropertyName.@PropertyGodotGenericArray, hint: (global::Godot.PropertyHint)23, hintString: "2/0:", usage: (global::Godot.PropertyUsageFlags)4102, exported: true));
+        return properties;
+    }
+#pragma warning restore CS0109
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ExportedProperties_ScriptPropertyDefVal.generated.cs

@@ -0,0 +1,147 @@
+partial class ExportedProperties
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+#if TOOLS
+    /// <summary>
+    /// Get the default values for all properties declared in this class.
+    /// This method is used by Godot to determine the value that will be
+    /// used by the inspector when resetting properties.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.Dictionary<global::Godot.StringName, global::Godot.Variant> GetGodotPropertyDefaultValues()
+    {
+        var values = new global::System.Collections.Generic.Dictionary<global::Godot.StringName, global::Godot.Variant>(64);
+        string __NotGenerateComplexLamdaProperty_default_value = default;
+        values.Add(PropertyName.@NotGenerateComplexLamdaProperty, global::Godot.Variant.From<string>(__NotGenerateComplexLamdaProperty_default_value));
+        string __NotGenerateLamdaNoFieldProperty_default_value = default;
+        values.Add(PropertyName.@NotGenerateLamdaNoFieldProperty, global::Godot.Variant.From<string>(__NotGenerateLamdaNoFieldProperty_default_value));
+        string __NotGenerateComplexReturnProperty_default_value = default;
+        values.Add(PropertyName.@NotGenerateComplexReturnProperty, global::Godot.Variant.From<string>(__NotGenerateComplexReturnProperty_default_value));
+        string __NotGenerateReturnsProperty_default_value = default;
+        values.Add(PropertyName.@NotGenerateReturnsProperty, global::Godot.Variant.From<string>(__NotGenerateReturnsProperty_default_value));
+        string __FullPropertyString_default_value = "FullPropertyString";
+        values.Add(PropertyName.@FullPropertyString, global::Godot.Variant.From<string>(__FullPropertyString_default_value));
+        string __FullPropertyString_Complex_default_value = new string("FullPropertyString_Complex")   + global::System.Convert.ToInt32("1");
+        values.Add(PropertyName.@FullPropertyString_Complex, global::Godot.Variant.From<string>(__FullPropertyString_Complex_default_value));
+        string __LamdaPropertyString_default_value = "LamdaPropertyString";
+        values.Add(PropertyName.@LamdaPropertyString, global::Godot.Variant.From<string>(__LamdaPropertyString_default_value));
+        bool __PropertyBoolean_default_value = true;
+        values.Add(PropertyName.@PropertyBoolean, global::Godot.Variant.From<bool>(__PropertyBoolean_default_value));
+        char __PropertyChar_default_value = 'f';
+        values.Add(PropertyName.@PropertyChar, global::Godot.Variant.From<char>(__PropertyChar_default_value));
+        sbyte __PropertySByte_default_value = 10;
+        values.Add(PropertyName.@PropertySByte, global::Godot.Variant.From<sbyte>(__PropertySByte_default_value));
+        short __PropertyInt16_default_value = 10;
+        values.Add(PropertyName.@PropertyInt16, global::Godot.Variant.From<short>(__PropertyInt16_default_value));
+        int __PropertyInt32_default_value = 10;
+        values.Add(PropertyName.@PropertyInt32, global::Godot.Variant.From<int>(__PropertyInt32_default_value));
+        long __PropertyInt64_default_value = -10_000;
+        values.Add(PropertyName.@PropertyInt64, global::Godot.Variant.From<long>(__PropertyInt64_default_value));
+        byte __PropertyByte_default_value = 10;
+        values.Add(PropertyName.@PropertyByte, global::Godot.Variant.From<byte>(__PropertyByte_default_value));
+        ushort __PropertyUInt16_default_value = 10;
+        values.Add(PropertyName.@PropertyUInt16, global::Godot.Variant.From<ushort>(__PropertyUInt16_default_value));
+        uint __PropertyUInt32_default_value = 10;
+        values.Add(PropertyName.@PropertyUInt32, global::Godot.Variant.From<uint>(__PropertyUInt32_default_value));
+        ulong __PropertyUInt64_default_value = 10;
+        values.Add(PropertyName.@PropertyUInt64, global::Godot.Variant.From<ulong>(__PropertyUInt64_default_value));
+        float __PropertySingle_default_value = 10;
+        values.Add(PropertyName.@PropertySingle, global::Godot.Variant.From<float>(__PropertySingle_default_value));
+        double __PropertyDouble_default_value = 10;
+        values.Add(PropertyName.@PropertyDouble, global::Godot.Variant.From<double>(__PropertyDouble_default_value));
+        string __PropertyString_default_value = "foo";
+        values.Add(PropertyName.@PropertyString, global::Godot.Variant.From<string>(__PropertyString_default_value));
+        global::Godot.Vector2 __PropertyVector2_default_value = new(10f, 10f);
+        values.Add(PropertyName.@PropertyVector2, global::Godot.Variant.From<global::Godot.Vector2>(__PropertyVector2_default_value));
+        global::Godot.Vector2I __PropertyVector2I_default_value = global::Godot.Vector2I.Up;
+        values.Add(PropertyName.@PropertyVector2I, global::Godot.Variant.From<global::Godot.Vector2I>(__PropertyVector2I_default_value));
+        global::Godot.Rect2 __PropertyRect2_default_value = new(new global::Godot.Vector2(10f, 10f), new global::Godot.Vector2(10f, 10f));
+        values.Add(PropertyName.@PropertyRect2, global::Godot.Variant.From<global::Godot.Rect2>(__PropertyRect2_default_value));
+        global::Godot.Rect2I __PropertyRect2I_default_value = new(new global::Godot.Vector2I(10, 10), new global::Godot.Vector2I(10, 10));
+        values.Add(PropertyName.@PropertyRect2I, global::Godot.Variant.From<global::Godot.Rect2I>(__PropertyRect2I_default_value));
+        global::Godot.Transform2D __PropertyTransform2D_default_value = global::Godot.Transform2D.Identity;
+        values.Add(PropertyName.@PropertyTransform2D, global::Godot.Variant.From<global::Godot.Transform2D>(__PropertyTransform2D_default_value));
+        global::Godot.Vector3 __PropertyVector3_default_value = new(10f, 10f, 10f);
+        values.Add(PropertyName.@PropertyVector3, global::Godot.Variant.From<global::Godot.Vector3>(__PropertyVector3_default_value));
+        global::Godot.Vector3I __PropertyVector3I_default_value = global::Godot.Vector3I.Back;
+        values.Add(PropertyName.@PropertyVector3I, global::Godot.Variant.From<global::Godot.Vector3I>(__PropertyVector3I_default_value));
+        global::Godot.Basis __PropertyBasis_default_value = new global::Godot.Basis(global::Godot.Quaternion.Identity);
+        values.Add(PropertyName.@PropertyBasis, global::Godot.Variant.From<global::Godot.Basis>(__PropertyBasis_default_value));
+        global::Godot.Quaternion __PropertyQuaternion_default_value = new global::Godot.Quaternion(global::Godot.Basis.Identity);
+        values.Add(PropertyName.@PropertyQuaternion, global::Godot.Variant.From<global::Godot.Quaternion>(__PropertyQuaternion_default_value));
+        global::Godot.Transform3D __PropertyTransform3D_default_value = global::Godot.Transform3D.Identity;
+        values.Add(PropertyName.@PropertyTransform3D, global::Godot.Variant.From<global::Godot.Transform3D>(__PropertyTransform3D_default_value));
+        global::Godot.Vector4 __PropertyVector4_default_value = new(10f, 10f, 10f, 10f);
+        values.Add(PropertyName.@PropertyVector4, global::Godot.Variant.From<global::Godot.Vector4>(__PropertyVector4_default_value));
+        global::Godot.Vector4I __PropertyVector4I_default_value = global::Godot.Vector4I.One;
+        values.Add(PropertyName.@PropertyVector4I, global::Godot.Variant.From<global::Godot.Vector4I>(__PropertyVector4I_default_value));
+        global::Godot.Projection __PropertyProjection_default_value = global::Godot.Projection.Identity;
+        values.Add(PropertyName.@PropertyProjection, global::Godot.Variant.From<global::Godot.Projection>(__PropertyProjection_default_value));
+        global::Godot.Aabb __PropertyAabb_default_value = new global::Godot.Aabb(10f, 10f, 10f, new global::Godot.Vector3(1f, 1f, 1f));
+        values.Add(PropertyName.@PropertyAabb, global::Godot.Variant.From<global::Godot.Aabb>(__PropertyAabb_default_value));
+        global::Godot.Color __PropertyColor_default_value = global::Godot.Colors.Aquamarine;
+        values.Add(PropertyName.@PropertyColor, global::Godot.Variant.From<global::Godot.Color>(__PropertyColor_default_value));
+        global::Godot.Plane __PropertyPlane_default_value = global::Godot.Plane.PlaneXZ;
+        values.Add(PropertyName.@PropertyPlane, global::Godot.Variant.From<global::Godot.Plane>(__PropertyPlane_default_value));
+        global::Godot.Callable __PropertyCallable_default_value = new global::Godot.Callable(global::Godot.Engine.GetMainLoop(), "_process");
+        values.Add(PropertyName.@PropertyCallable, global::Godot.Variant.From<global::Godot.Callable>(__PropertyCallable_default_value));
+        global::Godot.Signal __PropertySignal_default_value = new global::Godot.Signal(global::Godot.Engine.GetMainLoop(), "Propertylist_changed");
+        values.Add(PropertyName.@PropertySignal, global::Godot.Variant.From<global::Godot.Signal>(__PropertySignal_default_value));
+        global::ExportedProperties.MyEnum __PropertyEnum_default_value = global::ExportedProperties.MyEnum.C;
+        values.Add(PropertyName.@PropertyEnum, global::Godot.Variant.From<global::ExportedProperties.MyEnum>(__PropertyEnum_default_value));
+        global::ExportedProperties.MyFlagsEnum __PropertyFlagsEnum_default_value = global::ExportedProperties.MyFlagsEnum.C;
+        values.Add(PropertyName.@PropertyFlagsEnum, global::Godot.Variant.From<global::ExportedProperties.MyFlagsEnum>(__PropertyFlagsEnum_default_value));
+        byte[] __PropertyByteArray_default_value = { 0, 1, 2, 3, 4, 5, 6  };
+        values.Add(PropertyName.@PropertyByteArray, global::Godot.Variant.From<byte[]>(__PropertyByteArray_default_value));
+        int[] __PropertyInt32Array_default_value = { 0, 1, 2, 3, 4, 5, 6  };
+        values.Add(PropertyName.@PropertyInt32Array, global::Godot.Variant.From<int[]>(__PropertyInt32Array_default_value));
+        long[] __PropertyInt64Array_default_value = { 0, 1, 2, 3, 4, 5, 6  };
+        values.Add(PropertyName.@PropertyInt64Array, global::Godot.Variant.From<long[]>(__PropertyInt64Array_default_value));
+        float[] __PropertySingleArray_default_value = { 0f, 1f, 2f, 3f, 4f, 5f, 6f  };
+        values.Add(PropertyName.@PropertySingleArray, global::Godot.Variant.From<float[]>(__PropertySingleArray_default_value));
+        double[] __PropertyDoubleArray_default_value = { 0d, 1d, 2d, 3d, 4d, 5d, 6d  };
+        values.Add(PropertyName.@PropertyDoubleArray, global::Godot.Variant.From<double[]>(__PropertyDoubleArray_default_value));
+        string[] __PropertyStringArray_default_value = { "foo", "bar"  };
+        values.Add(PropertyName.@PropertyStringArray, global::Godot.Variant.From<string[]>(__PropertyStringArray_default_value));
+        string[] __PropertyStringArrayEnum_default_value = { "foo", "bar"  };
+        values.Add(PropertyName.@PropertyStringArrayEnum, global::Godot.Variant.From<string[]>(__PropertyStringArrayEnum_default_value));
+        global::Godot.Vector2[] __PropertyVector2Array_default_value = { global::Godot.Vector2.Up, global::Godot.Vector2.Down, global::Godot.Vector2.Left, global::Godot.Vector2.Right   };
+        values.Add(PropertyName.@PropertyVector2Array, global::Godot.Variant.From<global::Godot.Vector2[]>(__PropertyVector2Array_default_value));
+        global::Godot.Vector3[] __PropertyVector3Array_default_value = { global::Godot.Vector3.Up, global::Godot.Vector3.Down, global::Godot.Vector3.Left, global::Godot.Vector3.Right   };
+        values.Add(PropertyName.@PropertyVector3Array, global::Godot.Variant.From<global::Godot.Vector3[]>(__PropertyVector3Array_default_value));
+        global::Godot.Color[] __PropertyColorArray_default_value = { global::Godot.Colors.Aqua, global::Godot.Colors.Aquamarine, global::Godot.Colors.Azure, global::Godot.Colors.Beige   };
+        values.Add(PropertyName.@PropertyColorArray, global::Godot.Variant.From<global::Godot.Color[]>(__PropertyColorArray_default_value));
+        global::Godot.GodotObject[] __PropertyGodotObjectOrDerivedArray_default_value = { null  };
+        values.Add(PropertyName.@PropertyGodotObjectOrDerivedArray, global::Godot.Variant.CreateFrom(__PropertyGodotObjectOrDerivedArray_default_value));
+        global::Godot.StringName[] __field_StringNameArray_default_value = { "foo", "bar"  };
+        values.Add(PropertyName.@field_StringNameArray, global::Godot.Variant.From<global::Godot.StringName[]>(__field_StringNameArray_default_value));
+        global::Godot.NodePath[] __field_NodePathArray_default_value = { "foo", "bar"  };
+        values.Add(PropertyName.@field_NodePathArray, global::Godot.Variant.From<global::Godot.NodePath[]>(__field_NodePathArray_default_value));
+        global::Godot.Rid[] __field_RidArray_default_value = { default, default, default  };
+        values.Add(PropertyName.@field_RidArray, global::Godot.Variant.From<global::Godot.Rid[]>(__field_RidArray_default_value));
+        global::Godot.Variant __PropertyVariant_default_value = "foo";
+        values.Add(PropertyName.@PropertyVariant, global::Godot.Variant.From<global::Godot.Variant>(__PropertyVariant_default_value));
+        global::Godot.GodotObject __PropertyGodotObjectOrDerived_default_value = default;
+        values.Add(PropertyName.@PropertyGodotObjectOrDerived, global::Godot.Variant.From<global::Godot.GodotObject>(__PropertyGodotObjectOrDerived_default_value));
+        global::Godot.Texture __PropertyGodotResourceTexture_default_value = default;
+        values.Add(PropertyName.@PropertyGodotResourceTexture, global::Godot.Variant.From<global::Godot.Texture>(__PropertyGodotResourceTexture_default_value));
+        global::Godot.StringName __PropertyStringName_default_value = new global::Godot.StringName("foo");
+        values.Add(PropertyName.@PropertyStringName, global::Godot.Variant.From<global::Godot.StringName>(__PropertyStringName_default_value));
+        global::Godot.NodePath __PropertyNodePath_default_value = new global::Godot.NodePath("foo");
+        values.Add(PropertyName.@PropertyNodePath, global::Godot.Variant.From<global::Godot.NodePath>(__PropertyNodePath_default_value));
+        global::Godot.Rid __PropertyRid_default_value = default;
+        values.Add(PropertyName.@PropertyRid, global::Godot.Variant.From<global::Godot.Rid>(__PropertyRid_default_value));
+        global::Godot.Collections.Dictionary __PropertyGodotDictionary_default_value = new()  { { "foo", 10  }, { global::Godot.Vector2.Up, global::Godot.Colors.Chocolate   }  };
+        values.Add(PropertyName.@PropertyGodotDictionary, global::Godot.Variant.From<global::Godot.Collections.Dictionary>(__PropertyGodotDictionary_default_value));
+        global::Godot.Collections.Array __PropertyGodotArray_default_value = new()  { "foo", 10, global::Godot.Vector2.Up, global::Godot.Colors.Chocolate   };
+        values.Add(PropertyName.@PropertyGodotArray, global::Godot.Variant.From<global::Godot.Collections.Array>(__PropertyGodotArray_default_value));
+        global::Godot.Collections.Dictionary<string, bool> __PropertyGodotGenericDictionary_default_value = new()  { { "foo", true  }, { "bar", false  }  };
+        values.Add(PropertyName.@PropertyGodotGenericDictionary, global::Godot.Variant.CreateFrom(__PropertyGodotGenericDictionary_default_value));
+        global::Godot.Collections.Array<int> __PropertyGodotGenericArray_default_value = new()  { 0, 1, 2, 3, 4, 5, 6  };
+        values.Add(PropertyName.@PropertyGodotGenericArray, global::Godot.Variant.CreateFrom(__PropertyGodotGenericArray_default_value));
+        return values;
+    }
+#endif // TOOLS
+#pragma warning restore CS0109
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ExportedToolButtons_ScriptProperties.generated.cs

@@ -0,0 +1,48 @@
+using Godot;
+using Godot.NativeInterop;
+
+partial class ExportedToolButtons
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+    /// <summary>
+    /// Cached StringNames for the properties and fields contained in this class, for fast lookup.
+    /// </summary>
+    public new class PropertyName : global::Godot.GodotObject.PropertyName {
+        /// <summary>
+        /// Cached name for the 'MyButton1' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @MyButton1 = "MyButton1";
+        /// <summary>
+        /// Cached name for the 'MyButton2' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @MyButton2 = "MyButton2";
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool GetGodotClassPropertyValue(in godot_string_name name, out godot_variant value)
+    {
+        if (name == PropertyName.@MyButton1) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Callable>(this.@MyButton1);
+            return true;
+        }
+        if (name == PropertyName.@MyButton2) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Callable>(this.@MyButton2);
+            return true;
+        }
+        return base.GetGodotClassPropertyValue(name, out value);
+    }
+    /// <summary>
+    /// Get the property information for all the properties declared in this class.
+    /// This method is used by Godot to register the available properties in the editor.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo> GetGodotPropertyList()
+    {
+        var properties = new global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo>();
+        properties.Add(new(type: (global::Godot.Variant.Type)25, name: PropertyName.@MyButton1, hint: (global::Godot.PropertyHint)39, hintString: "Click me!", usage: (global::Godot.PropertyUsageFlags)4, exported: true));
+        properties.Add(new(type: (global::Godot.Variant.Type)25, name: PropertyName.@MyButton2, hint: (global::Godot.PropertyHint)39, hintString: "Click me!,ColorRect", usage: (global::Godot.PropertyUsageFlags)4, exported: true));
+        return properties;
+    }
+#pragma warning restore CS0109
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/Foo_ScriptPath.generated.cs

@@ -0,0 +1,5 @@
+using Godot;
+[ScriptPathAttribute("res://Foo.cs")]
+partial class Foo
+{
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/Generic(Of T)_ScriptPath.generated.cs

@@ -0,0 +1,5 @@
+using Godot;
+[ScriptPathAttribute("res://Generic.cs")]
+partial class Generic<T>
+{
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/GenericClass(Of T).NestedClass_ScriptMethods.generated.cs

@@ -0,0 +1,16 @@
+using Godot;
+using Godot.NativeInterop;
+
+partial class GenericClass<T>
+{
+partial class NestedClass
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+    /// <summary>
+    /// Cached StringNames for the methods contained in this class, for fast lookup.
+    /// </summary>
+    public new class MethodName : global::Godot.GodotObject.MethodName {
+    }
+#pragma warning restore CS0109
+}
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/Methods_ScriptMethods.generated.cs

@@ -0,0 +1,61 @@
+using Godot;
+using Godot.NativeInterop;
+
+partial class Methods
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+    /// <summary>
+    /// Cached StringNames for the methods contained in this class, for fast lookup.
+    /// </summary>
+    public new class MethodName : global::Godot.GodotObject.MethodName {
+        /// <summary>
+        /// Cached name for the 'MethodWithOverload' method.
+        /// </summary>
+        public new static readonly global::Godot.StringName @MethodWithOverload = "MethodWithOverload";
+    }
+    /// <summary>
+    /// Get the method information for all the methods declared in this class.
+    /// This method is used by Godot to register the available methods in the editor.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.List<global::Godot.Bridge.MethodInfo> GetGodotMethodList()
+    {
+        var methods = new global::System.Collections.Generic.List<global::Godot.Bridge.MethodInfo>(3);
+        methods.Add(new(name: MethodName.@MethodWithOverload, returnVal: new(type: (global::Godot.Variant.Type)0, name: "", hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)6, exported: false), flags: (global::Godot.MethodFlags)1, arguments: null, defaultArguments: null));
+        methods.Add(new(name: MethodName.@MethodWithOverload, returnVal: new(type: (global::Godot.Variant.Type)0, name: "", hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)6, exported: false), flags: (global::Godot.MethodFlags)1, arguments: new() { new(type: (global::Godot.Variant.Type)2, name: "a", hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)6, exported: false),  }, defaultArguments: null));
+        methods.Add(new(name: MethodName.@MethodWithOverload, returnVal: new(type: (global::Godot.Variant.Type)0, name: "", hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)6, exported: false), flags: (global::Godot.MethodFlags)1, arguments: new() { new(type: (global::Godot.Variant.Type)2, name: "a", hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)6, exported: false), new(type: (global::Godot.Variant.Type)2, name: "b", hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)6, exported: false),  }, defaultArguments: null));
+        return methods;
+    }
+#pragma warning restore CS0109
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool InvokeGodotClassMethod(in godot_string_name method, NativeVariantPtrArgs args, out godot_variant ret)
+    {
+        if (method == MethodName.@MethodWithOverload && args.Count == 0) {
+            @MethodWithOverload();
+            ret = default;
+            return true;
+        }
+        if (method == MethodName.@MethodWithOverload && args.Count == 1) {
+            @MethodWithOverload(global::Godot.NativeInterop.VariantUtils.ConvertTo<int>(args[0]));
+            ret = default;
+            return true;
+        }
+        if (method == MethodName.@MethodWithOverload && args.Count == 2) {
+            @MethodWithOverload(global::Godot.NativeInterop.VariantUtils.ConvertTo<int>(args[0]), global::Godot.NativeInterop.VariantUtils.ConvertTo<int>(args[1]));
+            ret = default;
+            return true;
+        }
+        return base.InvokeGodotClassMethod(method, args, out ret);
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool HasGodotClassMethod(in godot_string_name method)
+    {
+        if (method == MethodName.@MethodWithOverload) {
+           return true;
+        }
+        return base.HasGodotClassMethod(method);
+    }
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/MixedReadOnlyWriteOnly_ScriptProperties.generated.cs

@@ -0,0 +1,94 @@
+using Godot;
+using Godot.NativeInterop;
+
+partial class MixedReadOnlyWriteOnly
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+    /// <summary>
+    /// Cached StringNames for the properties and fields contained in this class, for fast lookup.
+    /// </summary>
+    public new class PropertyName : global::Godot.GodotObject.PropertyName {
+        /// <summary>
+        /// Cached name for the 'ReadOnlyAutoProperty' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @ReadOnlyAutoProperty = "ReadOnlyAutoProperty";
+        /// <summary>
+        /// Cached name for the 'ReadOnlyProperty' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @ReadOnlyProperty = "ReadOnlyProperty";
+        /// <summary>
+        /// Cached name for the 'InitOnlyAutoProperty' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @InitOnlyAutoProperty = "InitOnlyAutoProperty";
+        /// <summary>
+        /// Cached name for the 'WriteOnlyProperty' property.
+        /// </summary>
+        public new static readonly global::Godot.StringName @WriteOnlyProperty = "WriteOnlyProperty";
+        /// <summary>
+        /// Cached name for the 'ReadOnlyField' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @ReadOnlyField = "ReadOnlyField";
+        /// <summary>
+        /// Cached name for the '_writeOnlyBackingField' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_writeOnlyBackingField = "_writeOnlyBackingField";
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool SetGodotClassPropertyValue(in godot_string_name name, in godot_variant value)
+    {
+        if (name == PropertyName.@WriteOnlyProperty) {
+            this.@WriteOnlyProperty = global::Godot.NativeInterop.VariantUtils.ConvertTo<bool>(value);
+            return true;
+        }
+        if (name == PropertyName.@_writeOnlyBackingField) {
+            this.@_writeOnlyBackingField = global::Godot.NativeInterop.VariantUtils.ConvertTo<bool>(value);
+            return true;
+        }
+        return base.SetGodotClassPropertyValue(name, value);
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool GetGodotClassPropertyValue(in godot_string_name name, out godot_variant value)
+    {
+        if (name == PropertyName.@ReadOnlyAutoProperty) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@ReadOnlyAutoProperty);
+            return true;
+        }
+        if (name == PropertyName.@ReadOnlyProperty) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@ReadOnlyProperty);
+            return true;
+        }
+        if (name == PropertyName.@InitOnlyAutoProperty) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@InitOnlyAutoProperty);
+            return true;
+        }
+        if (name == PropertyName.@ReadOnlyField) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@ReadOnlyField);
+            return true;
+        }
+        if (name == PropertyName.@_writeOnlyBackingField) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<bool>(this.@_writeOnlyBackingField);
+            return true;
+        }
+        return base.GetGodotClassPropertyValue(name, out value);
+    }
+    /// <summary>
+    /// Get the property information for all the properties declared in this class.
+    /// This method is used by Godot to register the available properties in the editor.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo> GetGodotPropertyList()
+    {
+        var properties = new global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo>();
+        properties.Add(new(type: (global::Godot.Variant.Type)4, name: PropertyName.@ReadOnlyField, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4096, exported: false));
+        properties.Add(new(type: (global::Godot.Variant.Type)4, name: PropertyName.@ReadOnlyAutoProperty, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4096, exported: false));
+        properties.Add(new(type: (global::Godot.Variant.Type)4, name: PropertyName.@ReadOnlyProperty, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4096, exported: false));
+        properties.Add(new(type: (global::Godot.Variant.Type)4, name: PropertyName.@InitOnlyAutoProperty, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4096, exported: false));
+        properties.Add(new(type: (global::Godot.Variant.Type)1, name: PropertyName.@_writeOnlyBackingField, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4096, exported: false));
+        properties.Add(new(type: (global::Godot.Variant.Type)1, name: PropertyName.@WriteOnlyProperty, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4096, exported: false));
+        return properties;
+    }
+#pragma warning restore CS0109
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/NamespaceA.SameName_ScriptPath.generated.cs

@@ -0,0 +1,9 @@
+using Godot;
+namespace NamespaceA {
+
+[ScriptPathAttribute("res://SameName.cs")]
+partial class SameName
+{
+}
+
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/OuterClass.NestedClass_ScriptMethods.generated.cs

@@ -0,0 +1,52 @@
+using Godot;
+using Godot.NativeInterop;
+
+partial struct OuterClass
+{
+partial class NestedClass
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+    /// <summary>
+    /// Cached StringNames for the methods contained in this class, for fast lookup.
+    /// </summary>
+    public new class MethodName : global::Godot.RefCounted.MethodName {
+        /// <summary>
+        /// Cached name for the '_Get' method.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_Get = "_Get";
+    }
+    /// <summary>
+    /// Get the method information for all the methods declared in this class.
+    /// This method is used by Godot to register the available methods in the editor.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.List<global::Godot.Bridge.MethodInfo> GetGodotMethodList()
+    {
+        var methods = new global::System.Collections.Generic.List<global::Godot.Bridge.MethodInfo>(1);
+        methods.Add(new(name: MethodName.@_Get, returnVal: new(type: (global::Godot.Variant.Type)0, name: "", hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)131078, exported: false), flags: (global::Godot.MethodFlags)1, arguments: new() { new(type: (global::Godot.Variant.Type)21, name: "property", hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)6, exported: false),  }, defaultArguments: null));
+        return methods;
+    }
+#pragma warning restore CS0109
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool InvokeGodotClassMethod(in godot_string_name method, NativeVariantPtrArgs args, out godot_variant ret)
+    {
+        if (method == MethodName.@_Get && args.Count == 1) {
+            var callRet = @_Get(global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.StringName>(args[0]));
+            ret = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.Variant>(callRet);
+            return true;
+        }
+        return base.InvokeGodotClassMethod(method, args, out ret);
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool HasGodotClassMethod(in godot_string_name method)
+    {
+        if (method == MethodName.@_Get) {
+           return true;
+        }
+        return base.HasGodotClassMethod(method);
+    }
+}
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/OuterClass.NestedClass_ScriptProperties.generated.cs

@@ -0,0 +1,15 @@
+using Godot;
+using Godot.NativeInterop;
+
+partial struct OuterClass
+{
+partial class NestedClass
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+    /// <summary>
+    /// Cached StringNames for the properties and fields contained in this class, for fast lookup.
+    /// </summary>
+    public new class PropertyName : global::Godot.RefCounted.PropertyName {
+    }
+}
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/OuterClass.NestedClass_ScriptSerialization.generated.cs

@@ -0,0 +1,21 @@
+using Godot;
+using Godot.NativeInterop;
+
+partial struct OuterClass
+{
+partial class NestedClass
+{
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override void SaveGodotObjectData(global::Godot.Bridge.GodotSerializationInfo info)
+    {
+        base.SaveGodotObjectData(info);
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override void RestoreGodotObjectData(global::Godot.Bridge.GodotSerializationInfo info)
+    {
+        base.RestoreGodotObjectData(info);
+    }
+}
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ScriptBoilerplate_ScriptMethods.generated.cs

@@ -0,0 +1,62 @@
+using Godot;
+using Godot.NativeInterop;
+
+partial class ScriptBoilerplate
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+    /// <summary>
+    /// Cached StringNames for the methods contained in this class, for fast lookup.
+    /// </summary>
+    public new class MethodName : global::Godot.Node.MethodName {
+        /// <summary>
+        /// Cached name for the '_Process' method.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_Process = "_Process";
+        /// <summary>
+        /// Cached name for the 'Bazz' method.
+        /// </summary>
+        public new static readonly global::Godot.StringName @Bazz = "Bazz";
+    }
+    /// <summary>
+    /// Get the method information for all the methods declared in this class.
+    /// This method is used by Godot to register the available methods in the editor.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.List<global::Godot.Bridge.MethodInfo> GetGodotMethodList()
+    {
+        var methods = new global::System.Collections.Generic.List<global::Godot.Bridge.MethodInfo>(2);
+        methods.Add(new(name: MethodName.@_Process, returnVal: new(type: (global::Godot.Variant.Type)0, name: "", hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)6, exported: false), flags: (global::Godot.MethodFlags)1, arguments: new() { new(type: (global::Godot.Variant.Type)3, name: "delta", hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)6, exported: false),  }, defaultArguments: null));
+        methods.Add(new(name: MethodName.@Bazz, returnVal: new(type: (global::Godot.Variant.Type)2, name: "", hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)6, exported: false), flags: (global::Godot.MethodFlags)1, arguments: new() { new(type: (global::Godot.Variant.Type)21, name: "name", hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)6, exported: false),  }, defaultArguments: null));
+        return methods;
+    }
+#pragma warning restore CS0109
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool InvokeGodotClassMethod(in godot_string_name method, NativeVariantPtrArgs args, out godot_variant ret)
+    {
+        if (method == MethodName.@_Process && args.Count == 1) {
+            @_Process(global::Godot.NativeInterop.VariantUtils.ConvertTo<double>(args[0]));
+            ret = default;
+            return true;
+        }
+        if (method == MethodName.@Bazz && args.Count == 1) {
+            var callRet = @Bazz(global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.StringName>(args[0]));
+            ret = global::Godot.NativeInterop.VariantUtils.CreateFrom<int>(callRet);
+            return true;
+        }
+        return base.InvokeGodotClassMethod(method, args, out ret);
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool HasGodotClassMethod(in godot_string_name method)
+    {
+        if (method == MethodName.@_Process) {
+           return true;
+        }
+        if (method == MethodName.@Bazz) {
+           return true;
+        }
+        return base.HasGodotClassMethod(method);
+    }
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ScriptBoilerplate_ScriptPath.generated.cs

@@ -0,0 +1,5 @@
+using Godot;
+[ScriptPathAttribute("res://ScriptBoilerplate.cs")]
+partial class ScriptBoilerplate
+{
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ScriptBoilerplate_ScriptProperties.generated.cs

@@ -0,0 +1,62 @@
+using Godot;
+using Godot.NativeInterop;
+
+partial class ScriptBoilerplate
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+    /// <summary>
+    /// Cached StringNames for the properties and fields contained in this class, for fast lookup.
+    /// </summary>
+    public new class PropertyName : global::Godot.Node.PropertyName {
+        /// <summary>
+        /// Cached name for the '_nodePath' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_nodePath = "_nodePath";
+        /// <summary>
+        /// Cached name for the '_velocity' field.
+        /// </summary>
+        public new static readonly global::Godot.StringName @_velocity = "_velocity";
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool SetGodotClassPropertyValue(in godot_string_name name, in godot_variant value)
+    {
+        if (name == PropertyName.@_nodePath) {
+            this.@_nodePath = global::Godot.NativeInterop.VariantUtils.ConvertTo<global::Godot.NodePath>(value);
+            return true;
+        }
+        if (name == PropertyName.@_velocity) {
+            this.@_velocity = global::Godot.NativeInterop.VariantUtils.ConvertTo<int>(value);
+            return true;
+        }
+        return base.SetGodotClassPropertyValue(name, value);
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override bool GetGodotClassPropertyValue(in godot_string_name name, out godot_variant value)
+    {
+        if (name == PropertyName.@_nodePath) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<global::Godot.NodePath>(this.@_nodePath);
+            return true;
+        }
+        if (name == PropertyName.@_velocity) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<int>(this.@_velocity);
+            return true;
+        }
+        return base.GetGodotClassPropertyValue(name, out value);
+    }
+    /// <summary>
+    /// Get the property information for all the properties declared in this class.
+    /// This method is used by Godot to register the available properties in the editor.
+    /// Do not call this method.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal new static global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo> GetGodotPropertyList()
+    {
+        var properties = new global::System.Collections.Generic.List<global::Godot.Bridge.PropertyInfo>();
+        properties.Add(new(type: (global::Godot.Variant.Type)22, name: PropertyName.@_nodePath, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4096, exported: false));
+        properties.Add(new(type: (global::Godot.Variant.Type)2, name: PropertyName.@_velocity, hint: (global::Godot.PropertyHint)0, hintString: "", usage: (global::Godot.PropertyUsageFlags)4096, exported: false));
+        return properties;
+    }
+#pragma warning restore CS0109
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/ScriptBoilerplate_ScriptSerialization.generated.cs

@@ -0,0 +1,24 @@
+using Godot;
+using Godot.NativeInterop;
+
+partial class ScriptBoilerplate
+{
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override void SaveGodotObjectData(global::Godot.Bridge.GodotSerializationInfo info)
+    {
+        base.SaveGodotObjectData(info);
+        info.AddProperty(PropertyName.@_nodePath, global::Godot.Variant.From<global::Godot.NodePath>(this.@_nodePath));
+        info.AddProperty(PropertyName.@_velocity, global::Godot.Variant.From<int>(this.@_velocity));
+    }
+    /// <inheritdoc/>
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    protected override void RestoreGodotObjectData(global::Godot.Bridge.GodotSerializationInfo info)
+    {
+        base.RestoreGodotObjectData(info);
+        if (info.TryGetProperty(PropertyName.@_nodePath, out var _value__nodePath))
+            this.@_nodePath = _value__nodePath.As<global::Godot.NodePath>();
+        if (info.TryGetProperty(PropertyName.@_velocity, out var _value__velocity))
+            this.@_velocity = _value__velocity.As<int>();
+    }
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/GeneratedSources/namespace.class_ScriptMethods.generated.cs

@@ -0,0 +1,17 @@
+using Godot;
+using Godot.NativeInterop;
+
+namespace @namespace {
+
+partial class @class
+{
+#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword
+    /// <summary>
+    /// Cached StringNames for the methods contained in this class, for fast lookup.
+    /// </summary>
+    public new class MethodName : global::Godot.GodotObject.MethodName {
+    }
+#pragma warning restore CS0109
+}
+
+}