Language server is now aware of variadic functions

Author: desplesda

YarnSpinner.LanguageServer.Tests/ActionDeclarationTests.cs

@@ -139,5 +139,40 @@ private static void CheckImplementationMatchesDeclaration(System.Delegate impl,
                 Types.TypeMappings[implParameter.ParameterType].Should().Be(declParameter.Type);
             }
         }
+
+        [Fact]
+        public void ActionsFoundInCSharpFile_AreIdentified()
+        {
+            // Given
+            var path = Path.Combine(TestUtility.PathToTestData, "TestWorkspace", "Project1", "ActionDeclarationUsage.yarn");
+
+            var workspace = new Workspace();
+            workspace.Root = Path.Combine(TestUtility.PathToTestData, "TestWorkspace", "Project1");
+            workspace.Configuration.CSharpLookup = true;
+            workspace.Initialize();
+
+            // When
+            var diagnostics = workspace
+                .GetDiagnostics()
+                .Where(d => d.Key.AbsolutePath.EndsWith("ActionDeclarationUsage.yarn"))
+                .SelectMany(d => d.Value);
+
+            // Then
+
+            diagnostics.Should().NotContain(d => d.Severity == DiagnosticSeverity.Error);
+
+            // A single command should be detected as unknown
+            diagnostics.Should().HaveCount(2);
+
+            diagnostics.Should().Contain(d => d.Message == "Could not find command definition for unknown_command",
+                "unknown_command is not declared");
+            diagnostics.Should().Contain(d => d.Message == "Could not find function definition for unknown_function",
+                "unknown_function is not declared");
+
+            // We should have detected the function with a params array as having the correct type
+            workspace.Projects.Single().Functions
+                .Should().Contain(f => f.YarnName == "function_with_params_array")
+                .Which.VariadicParameterType.Should().Be(Types.Number);
+        }
     }
 }

YarnSpinner.LanguageServer.Tests/TestData/TestWorkspace/Project1/ActionDeclarationUsage.yarn

@@ -0,0 +1,17 @@
+title: ActionDeclarationUsage
+---
+
+<<static_command_no_docs>>
+<<static_command_no_params>>
+<<static_command_with_params "test" 42>>
+<<instance_command_no_params>>
+<<instance_command_with_params Target "test" 42>>
+
+<<declare $result = 0>>
+<<set $result = function_with_params(1,"2")>>
+<<set $result = function_with_params_array(1,2,3,4)>>
+
+<<unknown_command>>
+<<set $result = unknown_function()>>
+
+===

YarnSpinner.LanguageServer.Tests/TestData/TestWorkspace/Project1/ExampleCommands.cs

@@ -55,6 +55,12 @@ public static int FunctionWithParams(int one, string two)
         return -1;
     }
 
+    [YarnFunction("function_with_params_array")]
+    public static int FunctionWithParamsArray(int one, params int[] ints)
+    {
+        return -1;
+    }
+
     /// <summary>
     /// This command has <c>nested XML</c> nodes.
     /// </summary>

YarnSpinner.LanguageServer/src/Server/Workspace/CSharpFileData.cs

@@ -233,16 +233,29 @@ private static Action GetActionFromMethod(MethodDeclarationSyntax method)
                 Signature = $"{method.Identifier.Text}{method.ParameterList}",
             };
 
-            foreach (var parameter in method.ParameterList.Parameters)
+            for (int i = 0; i < method.ParameterList.Parameters.Count; i++)
             {
-                action.Parameters.Add(new Action.ParameterInfo
+                ParameterSyntax? parameter = method.ParameterList.Parameters[i];
+
+                var isLastParameter = i == method.ParameterList.Parameters.Count - 1;
+
+                if (isLastParameter && parameter.Type is ArrayTypeSyntax arrayTypeSyntax)
+                {
+                    // If this is the last parameter and it's an array, then
+                    // this parameter is where all variadic parameters will go.
+                    action.VariadicParameterType = GetYarnType(arrayTypeSyntax.ElementType);
+                }
+                else
                 {
-                    Name = parameter.Identifier.ToString(),
-                    Description = GetParameterDocumentation(method, parameter.Identifier.ToString()),
-                    DisplayDefaultValue = parameter.Default?.Value?.ToString(),
-                    Type = GetYarnType(parameter.Type),
-                    DisplayTypeName = parameter.Type?.ToString() ?? "(unknown)",
-                });
+                    action.Parameters.Add(new Action.ParameterInfo
+                    {
+                        Name = parameter.Identifier.ToString(),
+                        Description = GetParameterDocumentation(method, parameter.Identifier.ToString()),
+                        DisplayDefaultValue = parameter.Default?.Value?.ToString(),
+                        Type = GetYarnType(parameter.Type),
+                        DisplayTypeName = parameter.Type?.ToString() ?? "(unknown)",
+                    });
+                }
             }
 
             return action;