Add support for excluding functions from coverage with attribute

[benjaminfuchs]

PR Summary

Fixes #2268

This pull request introduces support for excluding functions from code coverage analysis using the [ExcludeFromCodeCoverageAttribute()] attribute.

Changes:

• Updated the Get-CommandsInFile function to skip AST nodes within functions marked with [ExcludeFromCodeCoverageAttribute()].
• Added IsExcludedByAttribute to check if a function has the exclusion attribute applied, either fully qualified or resolved through using namespace.
• Implemented Get-NamespacesFromScript to identify and apply using namespace declarations for resolving unqualified attribute names (not sure if similar logic already exists in the codebase).
• Updated tests to verify exclusion functionality.

PR Checklist

• PR has meaningful title
• Summary describes changes
• PR is ready to be merged
  • If not, use the arrow next to Create Pull Request to mark it as a draft. PR can be marked Ready for review when it's ready.
• Tests are added/update (if required)
• Documentation is updated/added (if required)

[benjaminfuchs]

If the approach is valid, I'll refine the tests and add proper documentation. Feedback is welcome!

[fflaten]

Thank you for looking into this! It works as intended, though I've suggested some improvements.

While reviewing I realized we could make this more efficient, see comment about FindAll. So I'd like to discuss an alternative approach. See draft PR #2598 which should produce the same results.

[fflaten]

Please replace FunctionDefinitionAst with ScriptBlockAst in the logic so we can exclude whole scripts and other scriptblocks. Besides type change, you'll probably only need to remove .Body. in Get-AttributeNames.

# Script: ScriptBlockAst -> ParamBlockAst -> Attributes
$ast = {
    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute()]
    param($a, $b)
    $a + $b
}.Ast

# Function: FunctionDefinitionAst -> ScriptBlockAst (Body) -> ParamBlockAst -> Attributes
$ast = {
    function t {
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute()]
        param($a, $b)
        $a + $b
    }
}.Ast


# Adv function: FunctionDefinitionAst -> ScriptBlockAst (Body) -> ParamBlockAst -> Attributes
$ast = {
    function t {
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute()]
        param($a, $b)
        
        begin { $a + $b }
        process {}
        end {}
    }
}.Ast

# Random scriptblock: ScriptBlockAst -> ParamBlockAst -> Attributes
$ast = {
    1..10 | ForEach-Object {
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute()]
        param($a, $b)
        $a + $b
    }
}.Ast

[fflaten]

FindAll will trigger this for commands in nested scriptblocks even though a parent is excluded. Not ideal to reverse (check parents) on every step.

$ast = {
    1 | ForEach-Object {
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute()]
        param($a, $b)
        $a + $b
        2 | ForEach-Object {
            3 | ForEach-Object {
                continue
             }
        }
    }
}.Ast
$ast.FindAll($predicate, $searchNestedScriptBlocks)

# Processing .. output added in IsExcludedByAttribute

Processing 1
Processing ForEach-Object {
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute()]
        param($a, $b)
        $a + $b
        2 | ForEach-Object {
            3 | ForEach-Object {
                continue
             }
        }
    }
Processing $a + $b
Processing 2
Processing ForEach-Object {
            3 | ForEach-Object {
                continue
             }
        }
Processing 3
Processing ForEach-Object {
                continue
             }
Processing continue

Expression Redirections Extent
---------- ------------ ------                                                                                                                                      
1          {}           1                                                                                                                                           
           {}           ForEach-Object {… 

We could avoid this by rewriting to use an AstVisitor, stopping early at a ScriptBlockAst where the attribute is set.

[fflaten]

Suggested change

	return @()

nit: unnecessary?

[fflaten]

Suggested change

	return @()
	return

nit: unnecessary?

[fflaten]

Suggested change

	foreach ($usingStatement in $usingStatements) {
	$namespaces += $usingStatement.Name.Value
	}
	$namespaces = foreach ($usingStatement in $usingStatements) {
	$usingStatement.Name.Value
	}

more efficient to output directly or capture foreach {}

[fflaten]

Suggested change

$namespaces = @()

more efficient to output directly or capture foreach {}