Update function finder to work for filter and workflow keywords

Co-authored-by: Copilot <[email protected]>

Author: JustinGrote

src/PowerShellEditorServices/Utility/AstExtensions.cs

@@ -579,11 +579,12 @@ internal static ScriptExtentAdapter GetFunctionNameExtent(this FunctionDefinitio
         ScriptExtentAdapter funcExtent = new(ast.Extent);
         string? extentText = ast.Extent.Text;
 
-        if (TryGetFunctionNameOffsets(extentText, out int nameStartOffset, out int nameEndOffset))
+        if (!string.IsNullOrEmpty(extentText))
         {
+            (int nameStartOffset, int nameEndOffset) = GetFunctionNameOffsets(extentText, ast.Name);
             ScriptPosition originalStart = funcExtent.Start;
-            funcExtent.Start = GetPositionAtOffset(originalStart, extentText!, nameStartOffset);
-            funcExtent.End = GetPositionAtOffset(originalStart, extentText!, nameEndOffset);
+            funcExtent.Start = GetPositionAtOffset(originalStart, extentText, nameStartOffset);
+            funcExtent.End = GetPositionAtOffset(originalStart, extentText, nameEndOffset);
             return funcExtent;
         }
 
@@ -641,65 +642,55 @@ private static ScriptPosition AdjustPosition(
             basePosition.ColumnNumber + columnDelta,
             basePosition.Line);
 
-    private static bool TryGetFunctionNameOffsets(
-        string? text,
-        out int nameStartOffset,
-        out int nameEndOffset)
+    internal static (int NameStartOffset, int NameEndOffset) GetFunctionNameOffsets(
+        string text,
+        string functionName)
     {
-        nameStartOffset = 0;
-        nameEndOffset = 0;
-
-        if (text is null || text.Length == 0)
+        if (string.IsNullOrEmpty(text))
         {
-            return false;
+            throw new ArgumentException("Function definition text cannot be null or empty.", nameof(text));
         }
 
-        string nonNullText = text;
-
-        const string functionKeyword = "function";
-        int functionIndex = nonNullText.IndexOf(functionKeyword, StringComparison.OrdinalIgnoreCase);
-        if (functionIndex < 0)
+        if (string.IsNullOrEmpty(functionName))
         {
-            return false;
+            throw new ArgumentException("Function name cannot be null or empty.", nameof(functionName));
         }
 
-        int index = functionIndex + functionKeyword.Length;
-        while (index < nonNullText.Length && char.IsWhiteSpace(nonNullText[index]))
+        int keywordStart = 0;
+        while (keywordStart < text.Length && char.IsWhiteSpace(text[keywordStart]))
         {
-            index++;
+            keywordStart++;
         }
 
-        if (index >= nonNullText.Length)
+        if (keywordStart >= text.Length)
         {
-            return false;
+            throw new InvalidOperationException("Function definition text does not contain a declaration keyword.");
         }
 
-        nameStartOffset = index;
-
-        while (index < nonNullText.Length)
+        int keywordEnd = keywordStart;
+        while (keywordEnd < text.Length && !char.IsWhiteSpace(text[keywordEnd]))
         {
-            char current = nonNullText[index];
-
-            if (current == '`')
-            {
-                index++;
-                if (index < nonNullText.Length)
-                {
-                    index++;
-                }
+            keywordEnd++;
+        }
 
-                continue;
-            }
+        string keyword = text.Substring(keywordStart, keywordEnd - keywordStart);
+        bool isKnownKeyword = keyword.Equals("function", StringComparison.OrdinalIgnoreCase)
+            || keyword.Equals("filter", StringComparison.OrdinalIgnoreCase)
+            || keyword.Equals("workflow", StringComparison.OrdinalIgnoreCase);
 
-            if (char.IsWhiteSpace(current) || current == '{' || current == '(')
-            {
-                break;
-            }
+        if (!isKnownKeyword)
+        {
+            throw new InvalidOperationException($"Unexpected function definition keyword '{keyword}'.");
+        }
 
-            index++;
+        int nameStartOffset = text.IndexOf(functionName, keywordEnd, StringComparison.Ordinal);
+        if (nameStartOffset < 0)
+        {
+            throw new InvalidOperationException($"Could not find function name '{functionName}' in function definition text.");
         }
 
-        nameEndOffset = index;
-        return nameEndOffset > nameStartOffset;
+        int nameEndOffset = nameStartOffset + functionName.Length;
+
+        return (nameStartOffset, nameEndOffset);
     }
 }

test/PowerShellEditorServices.Test.Shared/Refactoring/Functions/FunctionFilter.ps1

@@ -0,0 +1,5 @@
+filter AFilter {
+    $_
+}
+
+1..3 | AFilter

test/PowerShellEditorServices.Test.Shared/Refactoring/Functions/FunctionFilterRenamed.ps1

@@ -0,0 +1,5 @@
+filter Renamed {
+    $_
+}
+
+1..3 | Renamed

test/PowerShellEditorServices.Test.Shared/Refactoring/Functions/FunctionWorkflow.ps1

@@ -0,0 +1,5 @@
+workflow AWorkflow {
+    "workflow"
+}
+
+AWorkflow

test/PowerShellEditorServices.Test.Shared/Refactoring/Functions/FunctionWorkflowRenamed.ps1

@@ -0,0 +1,5 @@
+workflow Renamed {
+    "workflow"
+}
+
+Renamed

test/PowerShellEditorServices.Test.Shared/Refactoring/Functions/_RefactorFunctionTestCases.cs

@@ -16,6 +16,7 @@ public static class RefactorFunctionTestCases
         new("FunctionSimple.ps1",                      Line:  1, Column: 11, NewName: "Bad Name", ShouldThrow: true ),
         new("FunctionCallWIthinStringExpression.ps1",  Line:  1, Column: 10 ),
         new("FunctionCmdlet.ps1",                      Line:  1, Column: 10 ),
+        new("FunctionFilter.ps1",                      Line:  1, Column:  8 ),
         new("FunctionForeach.ps1",                     Line: 11, Column:  5 ),
         new("FunctionForeachObject.ps1",               Line: 11, Column:  5 ),
         new("FunctionInnerIsNested.ps1",               Line:  5, Column:  5 ),
@@ -27,5 +28,6 @@ public static class RefactorFunctionTestCases
         new("FunctionScriptblock.ps1",                 Line:  5, Column:  5 ),
         new("FunctionWithInnerFunction.ps1",           Line:  5, Column:  5 ),
         new("FunctionWithInternalCalls.ps1",           Line:  3, Column:  6 ),
+        new("FunctionWorkflow.ps1",                    Line:  1, Column: 10 ),
     ];
 }

test/PowerShellEditorServices.Test/Utility/AstExtensionsTests.cs

@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using Microsoft.PowerShell.EditorServices.Language;
+using Xunit;
+
+namespace PowerShellEditorServices.Test.Utility;
+
+[Trait("Category", "AstExtensions")]
+public class AstExtensionsTests
+{
+    [Fact]
+    public void GetFunctionNameOffsetsHandlesFilter()
+    {
+        const string definition = "filter AFilter { $_ }";
+        const string name = "AFilter";
+
+        (int start, int end) = AstExtensions.GetFunctionNameOffsets(definition, name);
+
+        Assert.Equal(definition.IndexOf(name, StringComparison.Ordinal), start);
+        Assert.Equal(start + name.Length, end);
+    }
+
+    [Fact]
+    public void GetFunctionNameOffsetsHandlesWorkflow()
+    {
+        const string definition = "workflow AWorkflow { \"ok\" }";
+        const string name = "AWorkflow";
+
+        (int start, int end) = AstExtensions.GetFunctionNameOffsets(definition, name);
+
+        Assert.Equal(definition.IndexOf(name, StringComparison.Ordinal), start);
+        Assert.Equal(start + name.Length, end);
+    }
+
+    [Fact]
+    public void GetFunctionNameOffsetsThrowsForUnexpectedKeyword()
+    {
+        InvalidOperationException ex = Assert.Throws<InvalidOperationException>(
+            () => AstExtensions.GetFunctionNameOffsets("configuration MyConfig {}", "MyConfig"));
+
+        Assert.Contains("Unexpected function definition keyword", ex.Message);
+    }
+}