C#: Escape generated members

.github/workflows/static_checks.yml

@@ -37,7 +37,7 @@ jobs:
           fi
           echo "$files" >> changed.txt
           cat changed.txt
-          files=$(echo "$files" | grep -v 'thirdparty' | xargs -I {} sh -c 'echo "./{}"' | tr '\n' ' ')
+          files=$(echo "$files" | grep -v 'thirdparty' | xargs -I {} sh -c 'echo "\"./{}\""' | tr '\n' ' ')
           echo "CHANGED_FILES=$files" >> $GITHUB_ENV
 
       # This needs to happen before Python and npm execution; it must happen before any extra files are written.

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

@@ -11,14 +11,14 @@ partial class AbstractGenericNode<T>
         /// <summary>
         /// Cached name for the 'MyArray' property.
         /// </summary>
-        public new static readonly global::Godot.StringName MyArray = "MyArray";
+        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);
+        if (name == PropertyName.@MyArray) {
+            this.@MyArray = global::Godot.NativeInterop.VariantUtils.ConvertToArray<T>(value);
             return true;
         }
         return base.SetGodotClassPropertyValue(name, value);
@@ -27,8 +27,8 @@ partial class AbstractGenericNode<T>
     [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);
+        if (name == PropertyName.@MyArray) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFromArray(this.@MyArray);
             return true;
         }
         return base.GetGodotClassPropertyValue(name, out value);
@@ -42,7 +42,7 @@ partial class AbstractGenericNode<T>
     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));
+        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

@@ -11,38 +11,38 @@ partial class AllReadOnly
         /// <summary>
         /// Cached name for the 'ReadOnlyAutoProperty' property.
         /// </summary>
-        public new static readonly global::Godot.StringName ReadOnlyAutoProperty = "ReadOnlyAutoProperty";
+        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";
+        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";
+        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";
+        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);
+        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);
+        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);
+        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);
+        if (name == PropertyName.@ReadOnlyField) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<string>(this.@ReadOnlyField);
             return true;
         }
         return base.GetGodotClassPropertyValue(name, out value);
@@ -56,10 +56,10 @@ partial class AllReadOnly
     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)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

@@ -11,22 +11,22 @@ partial class AllWriteOnly
         /// <summary>
         /// Cached name for the 'WriteOnlyProperty' property.
         /// </summary>
-        public new static readonly global::Godot.StringName WriteOnlyProperty = "WriteOnlyProperty";
+        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";
+        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);
+        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);
+        if (name == PropertyName.@_writeOnlyBackingField) {
+            this.@_writeOnlyBackingField = global::Godot.NativeInterop.VariantUtils.ConvertTo<bool>(value);
             return true;
         }
         return base.SetGodotClassPropertyValue(name, value);
@@ -35,8 +35,8 @@ partial class AllWriteOnly
     [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);
+        if (name == PropertyName.@_writeOnlyBackingField) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<bool>(this.@_writeOnlyBackingField);
             return true;
         }
         return base.GetGodotClassPropertyValue(name, out value);
@@ -50,8 +50,8 @@ partial class AllWriteOnly
     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));
+        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/EventSignals_ScriptSignals.generated.cs

@@ -11,7 +11,7 @@ partial class EventSignals
         /// <summary>
         /// Cached name for the 'MySignal' signal.
         /// </summary>
-        public new static readonly global::Godot.StringName MySignal = "MySignal";
+        public new static readonly global::Godot.StringName @MySignal = "MySignal";
     }
     /// <summary>
     /// Get the signal information for all the signals declared in this class.
@@ -22,13 +22,13 @@ partial class EventSignals
     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));
+        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 {
+    public event global::EventSignals.MySignalEventHandler @MySignal {
         add => backing_MySignal += value;
         remove => backing_MySignal -= value;
 }
@@ -36,7 +36,7 @@ partial class EventSignals
     [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) {
+        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;
         }
@@ -46,7 +46,7 @@ partial class EventSignals
     [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
     protected override bool HasGodotClassSignal(in godot_string_name signal)
     {
-        if (signal == SignalName.MySignal) {
+        if (signal == SignalName.@MySignal) {
            return true;
         }
         return base.HasGodotClassSignal(signal);

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

@@ -13,7 +13,7 @@ partial class ExportDiagnostics_GD0106_OK
     {
         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));
+        values.Add(PropertyName.@MyProperty, global::Godot.Variant.From<int>(__MyProperty_default_value));
         return values;
     }
 #endif // TOOLS

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

@@ -13,9 +13,9 @@ partial class ExportDiagnostics_GD0107_OK
     {
         var values = new global::System.Collections.Generic.Dictionary<global::Godot.StringName, global::Godot.Variant>(2);
         global::Godot.Node __NodeProperty_default_value = default;
-        values.Add(PropertyName.NodeProperty, global::Godot.Variant.From<global::Godot.Node>(__NodeProperty_default_value));
+        values.Add(PropertyName.@NodeProperty, global::Godot.Variant.From<global::Godot.Node>(__NodeProperty_default_value));
         global::Godot.Node __NodeField_default_value = default;
-        values.Add(PropertyName.NodeField, global::Godot.Variant.From<global::Godot.Node>(__NodeField_default_value));
+        values.Add(PropertyName.@NodeField, global::Godot.Variant.From<global::Godot.Node>(__NodeField_default_value));
         return values;
     }
 #endif // TOOLS

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

@@ -13,15 +13,15 @@ partial class ExportedComplexStrings
     {
         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));
+        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));
+        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));
+        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));
+        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));
+        values.Add(PropertyName.@_fieldInterpolated4, global::Godot.Variant.From<string>(___fieldInterpolated4_default_value));
         return values;
     }
 #endif // TOOLS

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

@@ -13,125 +13,125 @@ partial class ExportedFields
     {
         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));
+        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));
+        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));
+        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));
+        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));
+        values.Add(PropertyName.@_fieldInt32, global::Godot.Variant.From<int>(___fieldInt32_default_value));
         long ___fieldInt64_default_value = 10;
-        values.Add(PropertyName._fieldInt64, global::Godot.Variant.From<long>(___fieldInt64_default_value));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        values.Add(PropertyName.@_fieldEmptyInt64Array, global::Godot.Variant.From<long[]>(___fieldEmptyInt64Array_default_value));
         return values;
     }
 #endif // TOOLS

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

@@ -13,133 +13,133 @@ partial class ExportedProperties
     {
         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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        values.Add(PropertyName.@PropertyInt32, global::Godot.Variant.From<int>(__PropertyInt32_default_value));
         long __PropertyInt64_default_value = 10;
-        values.Add(PropertyName.PropertyInt64, global::Godot.Variant.From<long>(__PropertyInt64_default_value));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        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));
+        values.Add(PropertyName.@PropertyGodotGenericArray, global::Godot.Variant.CreateFrom(__PropertyGodotGenericArray_default_value));
         return values;
     }
 #endif // TOOLS

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

@@ -11,7 +11,7 @@ partial class Methods
         /// <summary>
         /// Cached name for the 'MethodWithOverload' method.
         /// </summary>
-        public new static readonly global::Godot.StringName MethodWithOverload = "MethodWithOverload";
+        public new static readonly global::Godot.StringName @MethodWithOverload = "MethodWithOverload";
     }
     /// <summary>
     /// Get the method information for all the methods declared in this class.
@@ -22,9 +22,9 @@ partial class Methods
     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));
+        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
@@ -32,18 +32,18 @@ partial class Methods
     [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();
+        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]));
+        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]));
+        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;
         }
@@ -53,7 +53,7 @@ partial class Methods
     [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
     protected override bool HasGodotClassMethod(in godot_string_name method)
     {
-        if (method == MethodName.MethodWithOverload) {
+        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

@@ -11,38 +11,38 @@ partial class MixedReadOnlyWriteOnly
         /// <summary>
         /// Cached name for the 'ReadOnlyAutoProperty' property.
         /// </summary>
-        public new static readonly global::Godot.StringName ReadOnlyAutoProperty = "ReadOnlyAutoProperty";
+        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";
+        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";
+        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";
+        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";
+        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";
+        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);
+        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);
+        if (name == PropertyName.@_writeOnlyBackingField) {
+            this.@_writeOnlyBackingField = global::Godot.NativeInterop.VariantUtils.ConvertTo<bool>(value);
             return true;
         }
         return base.SetGodotClassPropertyValue(name, value);
@@ -51,24 +51,24 @@ partial class MixedReadOnlyWriteOnly
     [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);
+        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);
+        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);
+        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);
+        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);
+        if (name == PropertyName.@_writeOnlyBackingField) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<bool>(this.@_writeOnlyBackingField);
             return true;
         }
         return base.GetGodotClassPropertyValue(name, out value);
@@ -82,12 +82,12 @@ partial class MixedReadOnlyWriteOnly
     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));
+        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/OuterClass.NestedClass_ScriptMethods.generated.cs

@@ -13,7 +13,7 @@ partial class NestedClass
         /// <summary>
         /// Cached name for the '_Get' method.
         /// </summary>
-        public new static readonly global::Godot.StringName _Get = "_Get";
+        public new static readonly global::Godot.StringName @_Get = "_Get";
     }
     /// <summary>
     /// Get the method information for all the methods declared in this class.
@@ -24,7 +24,7 @@ partial class NestedClass
     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));
+        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
@@ -32,8 +32,8 @@ partial class NestedClass
     [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]));
+        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;
         }
@@ -43,7 +43,7 @@ partial class NestedClass
     [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
     protected override bool HasGodotClassMethod(in godot_string_name method)
     {
-        if (method == MethodName._Get) {
+        if (method == MethodName.@_Get) {
            return true;
         }
         return base.HasGodotClassMethod(method);

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

@@ -11,11 +11,11 @@ partial class ScriptBoilerplate
         /// <summary>
         /// Cached name for the '_Process' method.
         /// </summary>
-        public new static readonly global::Godot.StringName _Process = "_Process";
+        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";
+        public new static readonly global::Godot.StringName @Bazz = "Bazz";
     }
     /// <summary>
     /// Get the method information for all the methods declared in this class.
@@ -26,8 +26,8 @@ partial class ScriptBoilerplate
     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));
+        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
@@ -35,13 +35,13 @@ partial class ScriptBoilerplate
     [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]));
+        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]));
+        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;
         }
@@ -51,10 +51,10 @@ partial class ScriptBoilerplate
     [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
     protected override bool HasGodotClassMethod(in godot_string_name method)
     {
-        if (method == MethodName._Process) {
+        if (method == MethodName.@_Process) {
            return true;
         }
-        if (method == MethodName.Bazz) {
+        if (method == MethodName.@Bazz) {
            return true;
         }
         return base.HasGodotClassMethod(method);

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

@@ -11,22 +11,22 @@ partial class ScriptBoilerplate
         /// <summary>
         /// Cached name for the '_nodePath' field.
         /// </summary>
-        public new static readonly global::Godot.StringName _nodePath = "_nodePath";
+        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";
+        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);
+        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);
+        if (name == PropertyName.@_velocity) {
+            this.@_velocity = global::Godot.NativeInterop.VariantUtils.ConvertTo<int>(value);
             return true;
         }
         return base.SetGodotClassPropertyValue(name, value);
@@ -35,12 +35,12 @@ partial class ScriptBoilerplate
     [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);
+        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);
+        if (name == PropertyName.@_velocity) {
+            value = global::Godot.NativeInterop.VariantUtils.CreateFrom<int>(this.@_velocity);
             return true;
         }
         return base.GetGodotClassPropertyValue(name, out value);
@@ -54,8 +54,8 @@ partial class ScriptBoilerplate
     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));
+        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

@@ -8,17 +8,17 @@ partial class ScriptBoilerplate
     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));
+        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>();
+        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/ScriptMethodsGenerator.cs

@@ -158,7 +158,7 @@ namespace Godot.SourceGenerators
                     .Append("' method.\n")
                     .Append("        /// </summary>\n");
 
-                source.Append("        public new static readonly global::Godot.StringName ");
+                source.Append("        public new static readonly global::Godot.StringName @");
                 source.Append(methodName);
                 source.Append(" = \"");
                 source.Append(methodName);
@@ -287,7 +287,7 @@ namespace Godot.SourceGenerators
 
         private static void AppendMethodInfo(StringBuilder source, MethodInfo methodInfo)
         {
-            source.Append("        methods.Add(new(name: MethodName.")
+            source.Append("        methods.Add(new(name: MethodName.@")
                 .Append(methodInfo.Name)
                 .Append(", returnVal: ");
 
@@ -414,7 +414,7 @@ namespace Godot.SourceGenerators
         )
         {
             source.Append("        ");
-            source.Append("if (method == MethodName.");
+            source.Append("if (method == MethodName.@");
             source.Append(methodName);
             source.Append(") {\n           return true;\n        }\n");
         }
@@ -426,7 +426,7 @@ namespace Godot.SourceGenerators
         {
             string methodName = method.Method.Name;
 
-            source.Append("        if (method == MethodName.");
+            source.Append("        if (method == MethodName.@");
             source.Append(methodName);
             source.Append(" && args.Count == ");
             source.Append(method.ParamTypes.Length);
@@ -437,6 +437,7 @@ namespace Godot.SourceGenerators
             else
                 source.Append("            ");
 
+            source.Append("@");
             source.Append(methodName);
             source.Append("(");
 

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators/ScriptPropertiesGenerator.cs

@@ -144,7 +144,7 @@ namespace Godot.SourceGenerators
                     .Append("' property.\n")
                     .Append("        /// </summary>\n");
 
-                source.Append("        public new static readonly global::Godot.StringName ");
+                source.Append("        public new static readonly global::Godot.StringName @");
                 source.Append(propertyName);
                 source.Append(" = \"");
                 source.Append(propertyName);
@@ -161,7 +161,7 @@ namespace Godot.SourceGenerators
                     .Append("' field.\n")
                     .Append("        /// </summary>\n");
 
-                source.Append("        public new static readonly global::Godot.StringName ");
+                source.Append("        public new static readonly global::Godot.StringName @");
                 source.Append(fieldName);
                 source.Append(" = \"");
                 source.Append(fieldName);
@@ -316,10 +316,10 @@ namespace Godot.SourceGenerators
         {
             source.Append("        ");
 
-            source.Append("if (name == PropertyName.")
+            source.Append("if (name == PropertyName.@")
                 .Append(propertyMemberName)
                 .Append(") {\n")
-                .Append("            this.")
+                .Append("            this.@")
                 .Append(propertyMemberName)
                 .Append(" = ")
                 .AppendNativeVariantToManagedExpr("value", propertyTypeSymbol, propertyMarshalType)
@@ -337,11 +337,11 @@ namespace Godot.SourceGenerators
         {
             source.Append("        ");
 
-            source.Append("if (name == PropertyName.")
+            source.Append("if (name == PropertyName.@")
                 .Append(propertyMemberName)
                 .Append(") {\n")
                 .Append("            value = ")
-                .AppendManagedToNativeVariantExpr("this." + propertyMemberName,
+                .AppendManagedToNativeVariantExpr("this.@" + propertyMemberName,
                     propertyTypeSymbol, propertyMarshalType)
                 .Append(";\n")
                 .Append("            return true;\n")
@@ -367,7 +367,7 @@ namespace Godot.SourceGenerators
         {
             source.Append("        properties.Add(new(type: (global::Godot.Variant.Type)")
                 .Append((int)propertyInfo.Type)
-                .Append(", name: PropertyName.")
+                .Append(", name: PropertyName.@")
                 .Append(propertyInfo.Name)
                 .Append(", hint: (global::Godot.PropertyHint)")
                 .Append((int)propertyInfo.Hint)

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators/ScriptPropertyDefValGenerator.cs

@@ -386,7 +386,7 @@ namespace Godot.SourceGenerators
                     source.Append(" = ");
                     source.Append(exportedMember.Value ?? "default");
                     source.Append(";\n");
-                    source.Append("        values.Add(PropertyName.");
+                    source.Append("        values.Add(PropertyName.@");
                     source.Append(exportedMember.Name);
                     source.Append(", ");
                     source.AppendManagedToVariantExpr(defaultValueLocalName,

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators/ScriptSerializationGenerator.cs

@@ -169,10 +169,10 @@ namespace Godot.SourceGenerators
             {
                 string propertyName = property.PropertySymbol.Name;
 
-                source.Append("        info.AddProperty(PropertyName.")
+                source.Append("        info.AddProperty(PropertyName.@")
                     .Append(propertyName)
                     .Append(", ")
-                    .AppendManagedToVariantExpr(string.Concat("this.", propertyName),
+                    .AppendManagedToVariantExpr(string.Concat("this.@", propertyName),
                         property.PropertySymbol.Type, property.Type)
                     .Append(");\n");
             }
@@ -183,10 +183,10 @@ namespace Godot.SourceGenerators
             {
                 string fieldName = field.FieldSymbol.Name;
 
-                source.Append("        info.AddProperty(PropertyName.")
+                source.Append("        info.AddProperty(PropertyName.@")
                     .Append(fieldName)
                     .Append(", ")
-                    .AppendManagedToVariantExpr(string.Concat("this.", fieldName),
+                    .AppendManagedToVariantExpr(string.Concat("this.@", fieldName),
                         field.FieldSymbol.Type, field.Type)
                     .Append(");\n");
             }
@@ -197,7 +197,7 @@ namespace Godot.SourceGenerators
             {
                 string signalName = signalDelegate.Name;
 
-                source.Append("        info.AddSignalEventDelegate(SignalName.")
+                source.Append("        info.AddSignalEventDelegate(SignalName.@")
                     .Append(signalName)
                     .Append(", this.backing_")
                     .Append(signalName)
@@ -218,12 +218,12 @@ namespace Godot.SourceGenerators
             {
                 string propertyName = property.PropertySymbol.Name;
 
-                source.Append("        if (info.TryGetProperty(PropertyName.")
+                source.Append("        if (info.TryGetProperty(PropertyName.@")
                     .Append(propertyName)
                     .Append(", out var _value_")
                     .Append(propertyName)
                     .Append("))\n")
-                    .Append("            this.")
+                    .Append("            this.@")
                     .Append(propertyName)
                     .Append(" = ")
                     .AppendVariantToManagedExpr(string.Concat("_value_", propertyName),
@@ -237,12 +237,12 @@ namespace Godot.SourceGenerators
             {
                 string fieldName = field.FieldSymbol.Name;
 
-                source.Append("        if (info.TryGetProperty(PropertyName.")
+                source.Append("        if (info.TryGetProperty(PropertyName.@")
                     .Append(fieldName)
                     .Append(", out var _value_")
                     .Append(fieldName)
                     .Append("))\n")
-                    .Append("            this.")
+                    .Append("            this.@")
                     .Append(fieldName)
                     .Append(" = ")
                     .AppendVariantToManagedExpr(string.Concat("_value_", fieldName),
@@ -259,7 +259,7 @@ namespace Godot.SourceGenerators
 
                 source.Append("        if (info.TryGetSignalEventDelegate<")
                     .Append(signalDelegateQualifiedName)
-                    .Append(">(SignalName.")
+                    .Append(">(SignalName.@")
                     .Append(signalName)
                     .Append(", out var _value_")
                     .Append(signalName)

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators/ScriptSignalsGenerator.cs

@@ -212,7 +212,7 @@ namespace Godot.SourceGenerators
                     .Append("' signal.\n")
                     .Append("        /// </summary>\n");
 
-                source.Append("        public new static readonly global::Godot.StringName ");
+                source.Append("        public new static readonly global::Godot.StringName @");
                 source.Append(signalName);
                 source.Append(" = \"");
                 source.Append(signalName);
@@ -278,7 +278,7 @@ namespace Godot.SourceGenerators
 
                 source.Append("    public event ")
                     .Append(signalDelegate.DelegateSymbol.FullQualifiedNameIncludeGlobal())
-                    .Append(" ")
+                    .Append(" @")
                     .Append(signalName)
                     .Append(" {\n")
                     .Append("        add => backing_")
@@ -353,7 +353,7 @@ namespace Godot.SourceGenerators
 
         private static void AppendMethodInfo(StringBuilder source, MethodInfo methodInfo)
         {
-            source.Append("        signals.Add(new(name: SignalName.")
+            source.Append("        signals.Add(new(name: SignalName.@")
                 .Append(methodInfo.Name)
                 .Append(", returnVal: ");
 
@@ -475,7 +475,7 @@ namespace Godot.SourceGenerators
         )
         {
             source.Append("        ");
-            source.Append("if (signal == SignalName.");
+            source.Append("if (signal == SignalName.@");
             source.Append(signalName);
             source.Append(") {\n           return true;\n        }\n");
         }
@@ -488,7 +488,7 @@ namespace Godot.SourceGenerators
             string signalName = signal.Name;
             var invokeMethodData = signal.InvokeMethodData;
 
-            source.Append("        if (signal == SignalName.");
+            source.Append("        if (signal == SignalName.@");
             source.Append(signalName);
             source.Append(" && args.Count == ");
             source.Append(invokeMethodData.ParamTypes.Length);