Merge pull request #47 from Sergio0694/feature_static-methods

Added support for static methods

src/ComputeSharp.Shaders/Extensions/SyntaxNodeExtensions.cs

@@ -42,12 +42,14 @@ public static TRoot ReplaceType<TRoot>(this TRoot node, TypeSyntax type) where T
         /// <param name="node">The input <see cref="MemberAccessExpressionSyntax"/> to check and modify if needed</param>
         /// <param name="semanticModel">The <see cref="SemanticModel"/> to use to load symbols for the input node</param>
         /// <param name="variable">The info on parsed static members, if any</param>
+        /// <param name="method">The info on parsed static methods, if any</param>
         /// <returns>A <see cref="SyntaxNode"/> instance that is compatible with HLSL</returns>
         [Pure]
-        public static SyntaxNode ReplaceMember(this MemberAccessExpressionSyntax node, SemanticModel semanticModel, out (string Name, ReadableMember MemberInfo)? variable)
+        public static SyntaxNode ReplaceMember(this MemberAccessExpressionSyntax node, SemanticModel semanticModel, out (string Name, ReadableMember MemberInfo)? variable, out (string Name, MethodInfo MethodInfo)? method)
         {
-            // Set the variable to null, replace it later on if needed
+            // Set the out parameters to null, replace them later on if needed
             variable = null;
+            method = null;
 
             SymbolInfo containingMemberSymbolInfo;
             ISymbol? memberSymbol;
@@ -115,37 +117,48 @@ public static SyntaxNode ReplaceMember(this MemberAccessExpressionSyntax node, S
                 return SyntaxFactory.IdentifierName(expression).WithLeadingTrivia(node.GetLeadingTrivia()).WithTrailingTrivia(node.GetTrailingTrivia());
             }
 
-            // Handle static fields as a special case
+            // Handle static members as a special case
             if (memberSymbol.IsStatic && (
                 memberSymbol.Kind == SymbolKind.Field ||
-                memberSymbol.Kind == SymbolKind.Property))
+                memberSymbol.Kind == SymbolKind.Property ||
+                memberSymbol.Kind == SymbolKind.Method))
             {
                 // Get the containing type
                 string
                     typeFullname = memberSymbol.ContainingType.ToString(),
                     assemblyFullname = memberSymbol.ContainingAssembly.ToString();
-                Type fieldDeclaringType = Type.GetType($"{typeFullname}, {assemblyFullname}");
+                Type memberDeclaringType = Type.GetType($"{typeFullname}, {assemblyFullname}");
 
-                // Retrieve the field or property info
-                bool isReadonly;
-                ReadableMember memberInfo;
-                switch (memberSymbol.Kind)
+                // Static field or property
+                if (memberSymbol.Kind == SymbolKind.Field || memberSymbol.Kind == SymbolKind.Property)
                 {
-                    case SymbolKind.Field:
-                        FieldInfo fieldInfo = fieldDeclaringType.GetField(memberSymbol.Name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
-                        isReadonly = fieldInfo.IsInitOnly;
-                        memberInfo = fieldInfo;
-                        break;
-                    case SymbolKind.Property:
-                        PropertyInfo propertyInfo = fieldDeclaringType.GetProperty(memberSymbol.Name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
-                        isReadonly = !propertyInfo.CanWrite;
-                        memberInfo = propertyInfo;
-                        break;
-                    default: throw new InvalidOperationException($"Invalid symbol kind: {memberSymbol.Kind}");
+                    bool isReadonly;
+                    ReadableMember memberInfo;
+                    switch (memberSymbol.Kind)
+                    {
+                        case SymbolKind.Field:
+                            FieldInfo fieldInfo = memberDeclaringType.GetField(memberSymbol.Name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
+                            isReadonly = fieldInfo.IsInitOnly;
+                            memberInfo = fieldInfo;
+                            break;
+                        case SymbolKind.Property:
+                            PropertyInfo propertyInfo = memberDeclaringType.GetProperty(memberSymbol.Name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
+                            isReadonly = !propertyInfo.CanWrite;
+                            memberInfo = propertyInfo;
+                            break;
+                        default: throw new InvalidOperationException($"Invalid symbol kind: {memberSymbol.Kind}");
+                    }
+
+                    // Handle the loaded info
+                    return ProcessStaticMember(node, memberInfo, isReadonly, ref variable);
                 }
 
-                // Handle the loaded info
-                return ProcessStaticMember(node, memberInfo, isReadonly, ref variable);
+                // Static method
+                MethodInfo methodInfo = memberDeclaringType.GetMethod(memberSymbol.Name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
+                string name = $"{methodInfo.DeclaringType.Name}_{methodInfo.Name}";
+                method = (name, methodInfo);
+
+                return SyntaxFactory.IdentifierName(name).WithLeadingTrivia(node.GetLeadingTrivia()).WithTrailingTrivia(node.GetTrailingTrivia());
             }
 
             return node;

src/ComputeSharp.Shaders/Renderer/Models/Functions/FunctionInfo.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using ComputeSharp.Shaders.Extensions;
+
+namespace ComputeSharp.Shaders.Renderer.Models.Functions
+{
+    /// <summary>
+    /// A <see langword="class"/> that contains info on a shader function
+    /// </summary>
+    internal class FunctionInfo
+    {
+        /// <summary>
+        /// Gets the return type of the current function in the C# source
+        /// </summary>
+        public string FunctionCsharpReturnType { get; }
+
+        /// <summary>
+        /// Gets the fullname of the current function in the C# source
+        /// </summary>
+        public string FunctionFullName { get; }
+
+        /// <summary>
+        /// Gets the parameters of the function in the C# source
+        /// </summary>
+        public string FunctionCsharpParameters { get; }
+
+        /// <summary>
+        /// Gets the return type of the current function
+        /// </summary>
+        public string ReturnType { get; }
+
+        /// <summary>
+        /// Gets the name of the current function
+        /// </summary>
+        public string FunctionName { get; }
+
+        /// <summary>
+        /// Gets the list of parameters for the current function
+        /// </summary>
+        public IReadOnlyList<ParameterInfo> ParametersList { get; }
+
+        /// <summary>
+        /// Gets the body of the current function
+        /// </summary>
+        public string FunctionBody { get; }
+
+        /// <summary>
+        /// Creates a new <see cref="FunctionInfo"/> instance with the specified parameters
+        /// </summary>
+        /// <param name="functionCsharpType">The concrete return type for the function</param>
+        /// <param name="functionFullname">The fullname of the function in the C# source</param>
+        /// <param name="functionCsharpParameters">The parameters of the function in the C# source</param>
+        /// <param name="returnType">The return type of the current function</param>
+        /// <param name="functionName">The name of the current function</param>
+        /// <param name="parameters">The function parameters, if any</param>
+        /// <param name="functionBody">The current function</param>
+        public FunctionInfo(
+            Type functionCsharpType,
+            string functionFullname,
+            string functionCsharpParameters,
+            string returnType,
+            string functionName,
+            IReadOnlyList<ParameterInfo> parameters,
+            string functionBody)
+        {
+            FunctionCsharpReturnType = functionCsharpType.ToFriendlyString();
+            FunctionFullName = functionFullname;
+            FunctionCsharpParameters = functionCsharpParameters;
+            ReturnType = returnType;
+            FunctionName = functionName;
+            ParametersList = parameters;
+            FunctionBody = functionBody;
+        }
+    }
+}

src/ComputeSharp.Shaders/Renderer/Models/Functions/ParameterInfo.cs

@@ -0,0 +1,52 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace ComputeSharp.Shaders.Renderer.Models.Functions
+{
+    /// <summary>
+    /// A <see langword="class"/> that contains info on a function parameter
+    /// </summary>
+    internal class ParameterInfo
+    {
+        /// <summary>
+        /// Gets the modifier to use for the current parameter
+        /// </summary>
+        public string ParameterModifier { get; }
+
+        /// <summary>
+        /// Gets the type of the current parameter
+        /// </summary>
+        public string ParameterType { get; }
+
+        /// <summary>
+        /// Gets the name to use for the current parameter
+        /// </summary>
+        public string ParameterName { get; }
+
+        /// <summary>
+        /// Gets whether or not the current parameter is the last one for the parent function
+        /// </summary>
+        public bool IsLastParameter { get; }
+
+        /// <summary>
+        /// Creates a new <see cref="ParameterInfo"/> instance with the specified parameters
+        /// </summary>
+        /// <param name="parameterModifiers">The modifiers used in the current parameter</param>
+        /// <param name="parameterType">The type of the current parameter</param>
+        /// <param name="parameterName">The name of the current parameter</param>
+        /// <param name="last">Indicates whether or not the current parameter is the last one</param>
+        public ParameterInfo(IReadOnlyList<SyntaxToken> parameterModifiers, string parameterType, string parameterName, bool last)
+        {
+            if (parameterModifiers.Count == 0) ParameterModifier = "in";
+            else if (parameterModifiers.First().IsKind(SyntaxKind.OutKeyword)) ParameterModifier = "out";
+            else if (parameterModifiers.Any(m => m.IsKind(SyntaxKind.RefKeyword)) && !parameterModifiers.Any(m => m.IsKind(SyntaxKind.ReadOnlyKeyword))) ParameterModifier = "inout";
+            else ParameterModifier = "in";
+
+            ParameterType = parameterType;
+            ParameterName = parameterName;
+            IsLastParameter = last;
+        }
+    }
+}

src/ComputeSharp.Shaders/Renderer/Models/ShaderInfo.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using ComputeSharp.Shaders.Renderer.Models.Fields;
 using ComputeSharp.Shaders.Renderer.Models.Fields.Abstract;
+using ComputeSharp.Shaders.Renderer.Models.Functions;
 
 #pragma warning disable CS8618 // Non-nullable field is uninitialized
 
@@ -12,12 +13,12 @@ namespace ComputeSharp.Shaders.Renderer.Models
     internal sealed class ShaderInfo
     {
         /// <summary>
-        /// Gets the list of captured buffers being present in the current shader
+        /// Gets or sets the list of captured buffers being present in the current shader
         /// </summary>
         public IReadOnlyList<HlslBufferInfo> BuffersList { get; set; }
 
         /// <summary>
-        /// Gets the list of captured variables being present in the current shader
+        /// Gets or sets the list of captured variables being present in the current shader
         /// </summary>
         public IReadOnlyList<CapturedFieldInfo> FieldsList { get; set; }
 
@@ -45,5 +46,10 @@ internal sealed class ShaderInfo
         /// Gets or sets the shader body to compile
         /// </summary>
         public string ShaderBody { get; set; }
+
+        /// <summary>
+        /// Gets or sets the list of static functions used by the shader
+        /// </summary>
+        public IReadOnlyList<FunctionInfo> FunctionsList { get; set; }
     }
 }

src/ComputeSharp.Shaders/Renderer/Templates/ShaderTemplate.mustache

@@ -39,6 +39,13 @@ cbuffer _{{FieldName}} : register(b{{BufferIndex}})
 {{/IsReadWriteBuffer}}
 {{/BuffersList}}
 
+{{!Shader private functions}}
+{{#FunctionsList}}
+// {{FunctionCsharpReturnType}} {{FunctionFullName}}({{FunctionCsharpParameters}})
+{{ReturnType}} {{FunctionName}}({{#ParametersList}}{{ParameterModifier}} {{ParameterType}} {{ParameterName}}{{^IsLastParameter}}, {{/IsLastParameter}}{{/ParametersList}})
+{{FunctionBody}}
+{{/FunctionsList}}
+
 {{!Shader entry point}}
 // Shader body
 [Shader("compute")]

src/ComputeSharp.Shaders/ShaderRunner.cs

@@ -76,7 +76,8 @@ public static void Run(
                     NumThreadsY = threadsY,
                     NumThreadsZ = threadsZ,
                     ThreadsIdsVariableName = shaderLoader.ThreadsIdsVariableName,
-                    ShaderBody = shaderLoader.MethodBody
+                    ShaderBody = shaderLoader.MethodBody,
+                    FunctionsList = shaderLoader.FunctionsList
                 };
                 string shaderSource = ShaderRenderer.Instance.Render(shaderInfo);
 

src/ComputeSharp.Shaders/Translation/Enums/MethodType.cs

@@ -0,0 +1,18 @@
+namespace ComputeSharp.Shaders.Translation.Enums
+{
+    /// <summary>
+    /// An <see langword="enum"/> that indicates a type of method to decompile
+    /// </summary>
+    internal enum MethodType
+    {
+        /// <summary>
+        /// An instance method that belongs to a closure class
+        /// </summary>
+        Closure,
+
+        /// <summary>
+        /// A standalone, static method
+        /// </summary>
+        Static
+    }
+}