Fix AvoidAlias execution-order and positional handling

Co-authored-by: bergmeister <9250262+bergmeister@users.noreply.github.com>

Author: Copilot

Rules/AvoidAlias.cs

@@ -398,9 +398,63 @@ private bool IsFunctionDeclaredAfterCommand(
             ScriptBlockAst commandScope,
             FunctionAnalysisContext functionAnalysis)
         {
-            return commandScope != null
-                && commandScope == GetFunctionScope(function, functionAnalysis)
-                && function.Extent.StartOffset > cmdAst.Extent.StartOffset;
+            if (commandScope == null || commandScope != GetFunctionScope(function, functionAnalysis))
+            {
+                return false;
+            }
+
+            int functionPhase = GetForEachObjectExecutionPhase(function, out CommandAst functionCallback);
+            int commandPhase = GetForEachObjectExecutionPhase(cmdAst, out CommandAst commandCallback);
+            if (functionCallback == commandCallback
+                && functionPhase >= 0
+                && commandPhase >= 0
+                && functionPhase != commandPhase)
+            {
+                return functionPhase > commandPhase;
+            }
+
+            return function.Extent.StartOffset > cmdAst.Extent.StartOffset;
+        }
+
+        private int GetForEachObjectExecutionPhase(Ast ast, out CommandAst callbackCommand)
+        {
+            callbackCommand = null;
+            for (Ast current = ast; current != null; current = current.Parent)
+            {
+                if (!(current is ScriptBlockAst scope)
+                    || !(scope.Parent is ScriptBlockExpressionAst scriptBlock))
+                {
+                    continue;
+                }
+
+                CommandAst commandAst = GetScriptBlockCommand(scriptBlock);
+                if (commandAst == null
+                    || !IsForEachObjectCommand(GetCallbackCommandName(commandAst)))
+                {
+                    continue;
+                }
+
+                string parameterName = GetScriptBlockParameterName(commandAst, scriptBlock);
+                if (IsParameter(parameterName, "Begin"))
+                {
+                    callbackCommand = commandAst;
+                    return 0;
+                }
+
+                if (IsParameter(parameterName, "Process"))
+                {
+                    callbackCommand = commandAst;
+                    return 1;
+                }
+
+                if (IsParameter(parameterName, "End"))
+                {
+                    callbackCommand = commandAst;
+                    return 2;
+                }
+            }
+
+            return -1;
         }
 
         private FunctionAnalysisContext GetFunctionNameIndex(Ast ast)
@@ -1017,8 +1071,10 @@ private bool IsRemoteInvokeCommand(CommandAst commandAst)
                 CommandElementAst element = commandAst.CommandElements[i];
                 if (element is CommandParameterAst parameter)
                 {
-                    if (parameter.Argument != null
-                        || (i + 1 < commandAst.CommandElements.Count
+                    ParameterMetadata metadata = ResolveParameter(parameters, parameter.ParameterName);
+                    if (parameter.Argument == null
+                        && metadata?.ParameterType != typeof(SwitchParameter)
+                        && (i + 1 < commandAst.CommandElements.Count
                             && !(commandAst.CommandElements[i + 1] is CommandParameterAst)))
                     {
                         i++;

Tests/Rules/AvoidUsingAlias.tests.ps1

@@ -108,6 +108,27 @@ gci -Path C:\
             $violations[0].SuggestedCorrections[0].Text | Should -Be 'Get-Verb'
         }
 
+        It "respects execution order across ForEach-Object callback phases" -TestCases @(
+            @{
+                Target = '1 | ForEach-Object -Process { Verb } -Begin { function Verb {} }'
+                ExpectedViolations = 0
+                ExpectedText = '1 | ForEach-Object -Process { Verb } -Begin { function Verb {} }'
+            }
+            @{
+                Target = '1 | ForEach-Object -Begin { Verb } -Process { function Verb {} }'
+                ExpectedViolations = 1
+                ExpectedText = '1 | ForEach-Object -Begin { Get-Verb } -Process { function Verb {} }'
+            }
+        ) {
+            param($Target, $ExpectedViolations, $ExpectedText)
+
+            $violations = @(Invoke-ScriptAnalyzer -ScriptDefinition $Target -IncludeRule $violationName)
+
+            $violations.Count | Should -Be $ExpectedViolations
+            $settings = @{ Rules = @{ PSAvoidUsingCmdletAliases = @{ Enable = $true } } }
+            Invoke-Formatter -ScriptDefinition $Target -Settings $settings | Should -Be $ExpectedText
+        }
+
         It "does not apply caller scope to script-block arguments of dot-invoked commands" {
             $target = 'function private:Verb {}; . Invoke-Command -ScriptBlock { Verb }'
             $violations = @(Invoke-ScriptAnalyzer -ScriptDefinition $target -IncludeRule $violationName)
@@ -241,6 +262,8 @@ Script Test {
             @{ Boundary = 'Invoke-Command -ComputerName localhost -ScriptBlock { Verb }' }
             @{ Boundary = 'Invoke-Command -Session $session -ScriptBlock { Verb }' }
             @{ Boundary = 'Invoke-Command localhost { Verb }' }
+            @{ Boundary = 'Invoke-Command -Verbose localhost -ScriptBlock { Verb }' }
+            @{ Boundary = 'Invoke-Command -Verbose:$true localhost -ScriptBlock { Verb }' }
             @{ Boundary = 'Invoke-Command -ConnectionUri http://server:5985/wsman -ScriptBlock { Verb }' }
             @{ Boundary = 'InlineScript { Verb }' }
             @{ Boundary = 'Script Test { GetScript = { Verb } }' }