Add GetNode Attribute for CSharp

Author: Hilderin

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators/AnalyzerReleases.Unshipped.md

@@ -3,3 +3,10 @@
 Rule ID | Category | Severity | Notes
 --------|----------|----------|--------------------
 GD0003  |  Usage   |  Error   | ScriptPathAttributeGenerator, [Documentation](https://docs.godotengine.org/en/latest/tutorials/scripting/c_sharp/diagnostics/GD0003.html)
+GD0501  |  Usage   |  Error   | ScriptMethodsGenerator, [Documentation](https://docs.godotengine.org/en/latest/tutorials/scripting/c_sharp/diagnostics/GD0501.html)
+GD0502  |  Usage   |  Error   | ScriptMethodsGenerator, [Documentation](https://docs.godotengine.org/en/latest/tutorials/scripting/c_sharp/diagnostics/GD0502.html)
+GD0503  |  Usage   |  Error   | ScriptMethodsGenerator, [Documentation](https://docs.godotengine.org/en/latest/tutorials/scripting/c_sharp/diagnostics/GD0503.html)
+GD0504  |  Usage   |  Error   | ScriptMethodsGenerator, [Documentation](https://docs.godotengine.org/en/latest/tutorials/scripting/c_sharp/diagnostics/GD0504.html)
+GD0505  |  Usage   |  Error   | ScriptMethodsGenerator, [Documentation](https://docs.godotengine.org/en/latest/tutorials/scripting/c_sharp/diagnostics/GD0505.html)
+GD0506  |  Usage   |  Error   | ScriptMethodsGenerator, [Documentation](https://docs.godotengine.org/en/latest/tutorials/scripting/c_sharp/diagnostics/GD0506.html)
+GD0507  |  Usage   |  Error   | ScriptMethodsGenerator, [Documentation](https://docs.godotengine.org/en/latest/tutorials/scripting/c_sharp/diagnostics/GD0507.html)

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

@@ -186,5 +186,75 @@ public static partial class Common
                 isEnabledByDefault: true,
                 "The class must not be generic. Make the class non-generic, or remove the '[GlobalClass]' attribute.",
                 helpLinkUri: string.Format(_helpLinkFormat, "GD0402"));
+
+        public static readonly DiagnosticDescriptor GetNodeMemberIsStaticRule =
+            new DiagnosticDescriptor(id: "GD0501",
+                title: "The GetNode member is static",
+                messageFormat: "The GetNode member '{0}' is static",
+                category: "Usage",
+                DiagnosticSeverity.Error,
+                isEnabledByDefault: true,
+                "The GetNode member is static. Only instance fields and properties can be GetNode. Remove the 'static' modifier, or the '[GetNode]' attribute.",
+                helpLinkUri: string.Format(_helpLinkFormat, "GD0501"));
+
+        public static readonly DiagnosticDescriptor GetNodeMemberIsReadOnlyRule =
+            new DiagnosticDescriptor(id: "GD0502",
+                title: "The GetNode member is read-only",
+                messageFormat: "The GetNode member '{0}' is read-only",
+                category: "Usage",
+                DiagnosticSeverity.Error,
+                isEnabledByDefault: true,
+                "The GetNode member is read-only. GetNode member must be writable.",
+                helpLinkUri: string.Format(_helpLinkFormat, "GD0501"));
+
+        public static readonly DiagnosticDescriptor GetNodeMemberIsIndexerRule =
+            new DiagnosticDescriptor(id: "GD0503",
+                title: "The GetNode property is an indexer",
+                messageFormat: "The GetNode property '{0}' is an indexer",
+                category: "Usage",
+                DiagnosticSeverity.Error,
+                isEnabledByDefault: true,
+                "The GetNode property is an indexer. Remove the '[GetNode]' attribute.",
+                helpLinkUri: string.Format(_helpLinkFormat, "GD0503"));
+
+        public static readonly DiagnosticDescriptor GetNodeMemberIsExplicitInterfaceImplementationRule =
+            new DiagnosticDescriptor(id: "GD0504",
+                title: "The GetNode property is an explicit interface implementation",
+                messageFormat: "The GetNode property '{0}' is an explicit interface implementation",
+                category: "Usage",
+                DiagnosticSeverity.Error,
+                isEnabledByDefault: true,
+                "The GetNode property is an explicit interface implementation. Remove the '[GetNode]' attribute.",
+                helpLinkUri: string.Format(_helpLinkFormat, "GD0504"));
+
+        public static readonly DiagnosticDescriptor GetNodeAttributePathIsEmpty =
+            new DiagnosticDescriptor(id: "GD0505",
+                title: "The GetNode attribute path is empty",
+                messageFormat: "The GetNode attribute path for member '{0}' is empty",
+                category: "Usage",
+                DiagnosticSeverity.Error,
+                isEnabledByDefault: true,
+                "The GetNode attribute path is empty. Set the 'Path' parameter in the '[GetNode]' attribute.",
+                helpLinkUri: string.Format(_helpLinkFormat, "GD0505"));
+
+        public static readonly DiagnosticDescriptor OnlyNodesShouldHaveGetNodeRule =
+            new DiagnosticDescriptor(id: "GD0506",
+                title: "Types not derived from Node should not have GetNode members",
+                messageFormat: "Types not derived from Node should not have GetNode members",
+                category: "Usage",
+                DiagnosticSeverity.Error,
+                isEnabledByDefault: true,
+                "Types not derived from Node should not have GetNode members. GetNode is only supported in Node-derived classes.",
+                helpLinkUri: string.Format(_helpLinkFormat, "GD0506"));
+
+        public static readonly DiagnosticDescriptor GetNodeMemberShouldBeNodes =
+            new DiagnosticDescriptor(id: "GD0507",
+                title: "The GetNode member type should derived from Node",
+                messageFormat: "The GetNode member type for member '{0}' should derived from Node",
+                category: "Usage",
+                DiagnosticSeverity.Error,
+                isEnabledByDefault: true,
+                "The GetNode member type should derived from Node. Remove the '[GetNode]' attribute or use a member type deriving from Node.",
+                helpLinkUri: string.Format(_helpLinkFormat, "GD0507"));
     }
 }

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

@@ -264,6 +264,9 @@ public static bool IsGodotGlobalClassAttribute(this INamedTypeSymbol symbol)
         public static bool IsSystemFlagsAttribute(this INamedTypeSymbol symbol)
             => symbol.FullQualifiedNameOmitGlobal() == GodotClasses.SystemFlagsAttr;
 
+        public static bool IsGodotGetNodeAttribute(this INamedTypeSymbol symbol)
+            => symbol.FullQualifiedNameOmitGlobal() == GodotClasses.GetNodeAttr;
+
         public static GodotMethodData? HasGodotCompatibleSignature(
             this IMethodSymbol method,
             MarshalUtils.TypeCache typeCache

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

@@ -14,5 +14,6 @@ public static class GodotClasses
         public const string GodotClassNameAttr = "Godot.GodotClassNameAttribute";
         public const string GlobalClassAttr = "Godot.GlobalClassAttribute";
         public const string SystemFlagsAttr = "System.FlagsAttribute";
+        public const string GetNodeAttr = "Godot.GetNodeAttribute";
     }
 }

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

@@ -82,6 +82,7 @@ INamedTypeSymbol symbol
             bool hasNamespace = classNs.Length != 0;
 
             bool isInnerClass = symbol.ContainingType != null;
+            bool isNode = symbol.InheritsFrom("GodotSharp", GodotClasses.Node);
 
             string uniqueHint = symbol.FullQualifiedNameOmitGlobal().SanitizeQualifiedNameForUniqueHint()
                                 + "_ScriptMethods.generated";
@@ -134,6 +135,27 @@ void AppendPartialContainingTypeDeclarations(INamedTypeSymbol? containingType)
                 .Distinct(new MethodOverloadEqualityComparer())
                 .ToArray();
 
+            List<ISymbol> getNode = new List<ISymbol>();
+            getNode.AddRange(members.Where(s => s.Kind == SymbolKind.Property)
+                                            .Cast<IPropertySymbol>()
+                                            .Where(s => s.GetAttributes()
+                                                .Any(a => a.AttributeClass?.IsGodotGetNodeAttribute() ?? false)));
+
+            getNode.AddRange(members.Where(s => s.Kind == SymbolKind.Field && !s.IsImplicitlyDeclared)
+                                            .Cast<IFieldSymbol>()
+                                            .Where(s => s.GetAttributes()
+                                                .Any(a => a.AttributeClass?.IsGodotGetNodeAttribute() ?? false)));
+
+
+            if (!isNode && getNode.Count > 0)
+            {
+                context.ReportDiagnostic(Diagnostic.Create(
+                    Common.OnlyNodesShouldHaveGetNodeRule,
+                    symbol.Locations.FirstLocationWithSourceTreeOrDefault()
+                ));
+                getNode.Clear();
+            }
+
             source.Append("#pragma warning disable CS0109 // Disable warning about redundant 'new' keyword\n");
 
             source.Append("    /// <summary>\n")
@@ -148,7 +170,10 @@ void AppendPartialContainingTypeDeclarations(INamedTypeSymbol? containingType)
             var distinctMethodNames = godotClassMethods
                 .Select(m => m.Method.Name)
                 .Distinct()
-                .ToArray();
+                .ToList();
+
+            if (getNode.Count > 0)
+                distinctMethodNames.Add("_InitGodotGetNodeMembers");
 
             foreach (string methodName in distinctMethodNames)
             {
@@ -205,13 +230,34 @@ void AppendPartialContainingTypeDeclarations(INamedTypeSymbol? containingType)
 
             // Generate InvokeGodotClassMethod
 
-            if (godotClassMethods.Length > 0)
+            if (getNode.Count > 0)
+            {
+                source.Append("    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]\n");
+                source.Append("    protected override void _InitGodotGetNodeMembers() {\n");
+                source.Append("        base._InitGodotGetNodeMembers();\n");
+                foreach (var member in getNode)
+                {
+                    AppendGetNodeSetter(context, source, member);
+                }
+                source.Append("    }\n");
+            }
+
+            if (godotClassMethods.Length > 0 || getNode.Count > 0)
             {
                 source.Append("    /// <inheritdoc/>\n");
                 source.Append("    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]\n");
                 source.Append("    protected override bool InvokeGodotClassMethod(in godot_string_name method, ");
                 source.Append("NativeVariantPtrArgs args, out godot_variant ret)\n    {\n");
 
+                if (getNode.Count > 0)
+                {
+                    source.Append("        if(method == global::Godot.Node.MethodName._Ready && args.Count == 0) {\n");
+                    source.Append("            _InitGodotGetNodeMembers();\n");
+                    source.Append("            ret = default;\n");
+                    source.Append("            return true;\n");
+                    source.Append("        }\n");
+                }
+
                 foreach (var method in godotClassMethods)
                 {
                     GenerateMethodInvoker(method, source);
@@ -247,7 +293,7 @@ void AppendPartialContainingTypeDeclarations(INamedTypeSymbol? containingType)
 
             // Generate HasGodotClassMethod
 
-            if (distinctMethodNames.Length > 0)
+            if (distinctMethodNames.Count > 0)
             {
                 source.Append("    /// <inheritdoc/>\n");
                 source.Append("    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]\n");
@@ -285,6 +331,130 @@ void AppendPartialContainingTypeDeclarations(INamedTypeSymbol? containingType)
             context.AddSource(uniqueHint, SourceText.From(source.ToString(), Encoding.UTF8));
         }
 
+        private static void AppendGetNodeSetter(GeneratorExecutionContext context, StringBuilder source, ISymbol symbol)
+        {
+            var attr = symbol.GetAttributes()
+                                                   .Where(a => a.AttributeClass?.IsGodotGetNodeAttribute() ?? false)
+                                                   .First();
+
+            string path = attr.ConstructorArguments.Length >= 0 ? attr.ConstructorArguments[0].Value as string ?? string.Empty : string.Empty;
+            if (string.IsNullOrEmpty(path))
+            {
+                context.ReportDiagnostic(Diagnostic.Create(
+                            Common.GetNodeAttributePathIsEmpty,
+                            symbol.Locations.FirstLocationWithSourceTreeOrDefault(),
+                            symbol.ToDisplayString()
+                        ));
+                return;
+            }
+
+            ITypeSymbol type;
+            if (symbol is IPropertySymbol)
+            {
+                var propertySymbol = (IPropertySymbol)symbol;
+                type = propertySymbol.Type;
+
+                if (propertySymbol.IsStatic)
+                {
+                    context.ReportDiagnostic(Diagnostic.Create(
+                            Common.GetNodeMemberIsStaticRule,
+                            symbol.Locations.FirstLocationWithSourceTreeOrDefault(),
+                            symbol.ToDisplayString()
+                        ));
+                    return;
+                }
+
+                if (propertySymbol.SetMethod == null || propertySymbol.SetMethod.IsInitOnly)
+                {
+                    context.ReportDiagnostic(Diagnostic.Create(
+                            Common.GetNodeMemberIsReadOnlyRule,
+                            symbol.Locations.FirstLocationWithSourceTreeOrDefault(),
+                            symbol.ToDisplayString()
+                        ));
+                    return;
+                }
+
+                if (propertySymbol.IsIndexer)
+                {
+                    context.ReportDiagnostic(Diagnostic.Create(
+                        Common.GetNodeMemberIsIndexerRule,
+                        propertySymbol.Locations.FirstLocationWithSourceTreeOrDefault(),
+                        propertySymbol.ToDisplayString()
+                    ));
+                    return;
+                }
+
+                if (propertySymbol.ExplicitInterfaceImplementations.Length > 0)
+                {
+                    context.ReportDiagnostic(Diagnostic.Create(
+                        Common.GetNodeMemberIsExplicitInterfaceImplementationRule,
+                        propertySymbol.Locations.FirstLocationWithSourceTreeOrDefault(),
+                        propertySymbol.ToDisplayString()
+                    ));
+                    return;
+                }
+            }
+            else if (symbol is IFieldSymbol)
+            {
+                var fieldSymbol = (IFieldSymbol)symbol;
+                type = fieldSymbol.Type;
+
+                if (fieldSymbol.IsStatic)
+                {
+                    context.ReportDiagnostic(Diagnostic.Create(
+                            Common.GetNodeMemberIsStaticRule,
+                            symbol.Locations.FirstLocationWithSourceTreeOrDefault(),
+                            symbol.ToDisplayString()
+                        ));
+                    return;
+                }
+
+                if (fieldSymbol.IsReadOnly)
+                {
+                    context.ReportDiagnostic(Diagnostic.Create(
+                            Common.GetNodeMemberIsReadOnlyRule,
+                            symbol.Locations.FirstLocationWithSourceTreeOrDefault(),
+                            symbol.ToDisplayString()
+                        ));
+                    return;
+                }
+
+            }
+            else
+            {
+                //Should not happen.
+                return;
+            }
+
+
+            if (!type.InheritsFrom("GodotSharp", GodotClasses.Node))
+            {
+                context.ReportDiagnostic(Diagnostic.Create(
+                    Common.GetNodeMemberShouldBeNodes,
+                    symbol.Locations.FirstLocationWithSourceTreeOrDefault(),
+                    symbol.ToDisplayString()
+                ));
+                return;
+            }
+
+            source.Append("        try\n");
+            source.Append("        {\n");
+            source.Append("            ")
+                  .Append(symbol.Name)
+                  .Append(" = GetNode<")
+                  .Append(type.Name)
+                  .Append(">(\"")
+                  .Append(attr.ConstructorArguments[0].Value)
+                  .Append("\");\n");
+            source.Append("        }\n");
+            source.Append("        catch (global::System.Exception e)\n");
+            source.Append("        {\n");
+            source.Append("            global::Godot.GD.PushError($\"Error GetNode for '{this.Name}.")
+                  .Append(symbol.Name)
+                  .Append("': {e.Message}\");\n");
+            source.Append("        }\n");
+        }
+
         private static void AppendMethodInfo(StringBuilder source, MethodInfo methodInfo)
         {
             source.Append("        methods.Add(new(name: MethodName.")

modules/mono/editor/bindings_generator.cpp

@@ -87,6 +87,7 @@ StringBuilder &operator<<(StringBuilder &r_sb, const char *p_cstring) {
 #define CS_METHOD_INVOKE_GODOT_CLASS_METHOD "InvokeGodotClassMethod"
 #define CS_METHOD_HAS_GODOT_CLASS_METHOD "HasGodotClassMethod"
 #define CS_METHOD_HAS_GODOT_CLASS_SIGNAL "HasGodotClassSignal"
+#define CS_METHOD_INIT_GODOT_GET_NODE_MEMBERS "_InitGodotGetNodeMembers"
 
 #define CS_STATIC_FIELD_NATIVE_CTOR "NativeCtor"
 #define CS_STATIC_FIELD_METHOD_BIND_PREFIX "MethodBind"
@@ -2431,6 +2432,21 @@ Error BindingsGenerator::_generate_cs_type(const TypeInterface &itype, const Str
 		}
 
 		output << INDENT1 "}\n";
+
+		if (itype.proxy_name == "Node") {
+			// Generate _InitGodotGetNodeMembers only for Node has the base method.
+			// If the [GetNode] attribute is used, the ScriptMethodsGenerator will generate an override for this method
+			// and put the assignations for GetNode property and fields into it.
+			output << MEMBER_BEGIN "/// <summary>\n"
+				   << INDENT1 "/// Initialize the properties and fields based on [GetNode] attribute.\n"
+				   << INDENT1 "/// This method is used internally by Godot.\n"
+				   << INDENT1 "/// Do not call or override this method.\n"
+				   << INDENT1 "/// </summary>\n";
+
+			output << INDENT1 "protected internal virtual void " CS_METHOD_INIT_GODOT_GET_NODE_MEMBERS "()\n"
+				   << INDENT1 "{\n";
+			output << INDENT1 "}\n";
+		}
 	}
 
 	//Generate StringName for all class members

modules/mono/glue/GodotSharp/GodotSharp/Core/Attributes/GetNodeAttribute.cs

@@ -0,0 +1,25 @@
+using System;
+
+namespace Godot
+{
+    /// <summary>
+    /// Define a resource to populate with a GetNode before _Ready.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
+    public sealed class GetNodeAttribute : Attribute
+    {
+        /// <summary>
+        /// Path of the resource in the scene.
+        /// </summary>
+        public string Path { get; }
+
+        /// <summary>
+        /// Constructs a new GetNodeAttribute Instance.
+        /// </summary>
+        /// <param name="path">Path of the resource in the scene.</param>
+        public GetNodeAttribute(string path)
+        {
+            Path = path;
+        }
+    }
+}

modules/mono/glue/GodotSharp/GodotSharp/GodotSharp.csproj

@@ -48,6 +48,7 @@
   <!-- Sources -->
   <ItemGroup>
     <Compile Include="Core\Aabb.cs" />
+    <Compile Include="Core\Attributes\GetNodeAttribute.cs" />
     <Compile Include="Core\Bridge\GodotSerializationInfo.cs" />
     <Compile Include="Core\Bridge\MethodInfo.cs" />
     <Compile Include="Core\Callable.generics.cs" />