Write-Host $AST

VisitorKittenz.ps1

using namespace System.Collections.Generic
using namespace System.Management.Automation.Language

#region AstVisitor 
class VisitorKitten : ICustomAstVisitor
{
    [int]GetDepth([Ast]$ast){
        $temp = $ast
        $count = 0
        while($temp -and $temp -ne $temp.Parent){
            $count++
            $temp = $temp.Parent
        }

        return $count
    }

    AstVisitor() {

    }

    [Object] VisitElement([object]$element) {
        if ($null -eq $element) {
            return $null
        }
        $res = $element.Visit($this)
        return $res
    }

    hidden
    [Object] VisitElements([Object]$elements) {
        if ($null -eq $elements -or $elements.Count -eq 0)
        {
            return $null
        }
        $typeName = $elements.gettype().GenericTypeArguments.Fullname

        $newElements = New-Object -TypeName "System.Collections.Generic.List[$typeName]"
        foreach($element in $elements) {
            $visitedResult = $element.Visit($this)
            $newElements.add($visitedResult)
        }
        return $newElements 
    }

    [StatementAst[]] VisitStatements([object]$Statements)
    {

        $newStatements = [List[StatementAst]]::new()
        foreach ($statement in $statements)
        {
            Write-Host "$(" " * $this.GetDepth($Statement))i'm in ur statementz"
            $newStatements.Add($this.VisitElement($statement))
        }
        return $newStatements
    }

    [object] VisitScriptBlock([ScriptBlockAst] $scriptBlockAst)
    {
        Write-Host "$(" " * $this.GetDepth($scriptBlockAst))i'm in ur script blockz"

        $newParamBlock = $this.VisitElement($scriptBlockAst.ParamBlock)
        $newBeginBlock = $this.VisitElement($scriptBlockAst.BeginBlock)
        $newProcessBlock = $this.VisitElement($scriptBlockAst.ProcessBlock)
        $newEndBlock = $this.VisitElement($scriptBlockAst.EndBlock)
        $newDynamicParamBlock = $this.VisitElement($scriptBlockAst.DynamicParamBlock)

        return [ScriptBlockAst]::new($scriptBlockAst.Extent, $newParamBlock, $newBeginBlock, $newProcessBlock, $newEndBlock, $newDynamicParamBlock)
    }


    [object] VisitNamedBlock([NamedBlockAst] $namedBlockAst)
    {
        Write-Host "$(" " * $this.GetDepth($namedBlockAst))i'm in ur named blockz"

        $newTraps = $this.VisitElements($namedBlockAst.Traps)
        $newStatements = $this.VisitStatements($namedBlockAst.Statements)
        $statementBlock = [StatementBlockAst]::new($namedBlockAst.Extent,$newStatements,$newTraps)
        return [NamedBlockAst]::new($namedBlockAst.Extent, $namedBlockAst.BlockKind, $statementBlock, $namedBlockAst.Unnamed)
    }

    [object] VisitFunctionDefinition([FunctionDefinitionAst] $functionDefinitionAst)
    {
        Write-Host "$(" " * $this.GetDepth($functionDefinitionAst))i'm in ur function definitionz"
        $newBody = $this.VisitElement($functionDefinitionAst.Body)
        return [FunctionDefinitionAst]::new($functionDefinitionAst.Extent, $functionDefinitionAst.IsFilter,$functionDefinitionAst.IsWorkflow, $functionDefinitionAst.Name, $this.VisitElements($functionDefinitionAst.Parameters), $newBody);
    }

    [object] VisitStatementBlock([StatementBlockAst] $statementBlockAst)
    {
        Write-Host "$(" " * $this.GetDepth($statementBlockAst))i'm in ur statement blockz"
        $newStatements = $this.VisitStatements($statementBlockAst.Statements)
        $newTraps = $this.VisitElements($statementBlockAst.Traps)
        return [StatementBlockAst]::new($statementBlockAst.Extent, $newStatements, $newTraps)
    }

    [object] VisitIfStatement([IfStatementAst] $ifStmtAst)
    {
        Write-Host "$(" " * $this.GetDepth($ifStmtAst))i'm in ur ifz"
        [Tuple[PipelineBaseAst,StatementBlockAst][]]$newClauses = @(foreach($clause in $ifStmtAst.Clauses){
            $newClauseTest = [PipelineBaseAst]$this.VisitElement($clause.Item1)
            $newStatementBlock = [StatementBlockAst]$this.VisitElement($clause.Item2)
            [Tuple[PipelineBaseAst,StatementBlockAst]]::new($newClauseTest,$newStatementBlock)
        })
        $newElseClause = $this.VisitElement($ifStmtAst.ElseClause)
        return [IfStatementAst]::new($ifStmtAst.Extent, $newClauses, $newElseClause)
    }

    [object] VisitTrap([TrapStatementAst] $trapStatementAst)
    {
        Write-Host "$(" " * $this.GetDepth($trapStatementAst))i'm in ur trapz"
        return [TrapStatementAst]::new($trapStatementAst.Extent, $this.VisitElement($trapStatementAst.TrapType), $this.VisitElement($trapStatementAst.Body))
    }

    [object] VisitSwitchStatement([SwitchStatementAst] $switchStatementAst)
    {
        Write-Host "$(" " * $this.GetDepth($switchStatementAst))i'm in ur switchez"

        $newCondition = $this.VisitElement($switchStatementAst.Condition)
        $newClauses = $switchStatementAst.Clauses | ForEach-Object {
            $newClauseTest = $this.VisitElement($_.Item1)
            $newStatementBlock = $this.VisitElement($_.Item2)
            [Tuple[ExpressionAst,StatementBlockAst]]::new($newClauseTest,$newStatementBlock)
        }
        $newDefault = $this.VisitElement($switchStatementAst.Default)
        return [SwitchStatementAst]::new($switchStatementAst.Extent, $switchStatementAst.Label,$newCondition,$switchStatementAst.Flags, $newClauses, $newDefault)
    }

    [object] VisitDataStatement([DataStatementAst] $dataStatementAst)
    {
        Write-Host "$(" " * $this.GetDepth($dataStatementAst))i'm in ur DATAZ"

        $newBody = $this.VisitElement($dataStatementAst.Body)
        $newCommandsAllowed = $this.VisitElements($dataStatementAst.CommandsAllowed)
        return [DataStatementAst]::new($dataStatementAst.Extent, $dataStatementAst.Variable, $newCommandsAllowed, $newBody)
    }

    [object] VisitForEachStatement([ForEachStatementAst] $forEachStatementAst)
    {
        Write-Host "$(" " * $this.GetDepth($forEachStatementAst))i'm in ur foreachez"

        $newVariable = $this.VisitElement($forEachStatementAst.Variable)
        $newCondition = $this.VisitElement($forEachStatementAst.Condition)
        $newBody = $this.VisitElement($forEachStatementAst.Body)
        return [ForEachStatementAst]::new($forEachStatementAst.Extent, $forEachStatementAst.Label, [ForEachFlags]::None, $newVariable, $newCondition, $newBody)
    }

    [object] VisitDoWhileStatement([DoWhileStatementAst] $doWhileStatementAst)
    {
        Write-Host "$(" " * $this.GetDepth($doWhileStatementAst))i'm in ur do-whilez"

        $newCondition = $this.VisitElement($doWhileStatementAst.Condition)
        $newBody = $this.VisitElement($doWhileStatementAst.Body)
        return [DoWhileStatementAst]::new($doWhileStatementAst.Extent, $doWhileStatementAst.Label, $newCondition, $newBody)
    }

    [object] VisitForStatement([ForStatementAst] $forStatementAst)
    {
        Write-Host "$(" " * $this.GetDepth($forStatementAst))i'm in ur forz"

        $newInitializer = $this.VisitElement($forStatementAst.Initializer)
        $newCondition = $this.VisitElement($forStatementAst.Condition)
        $newIterator = $this.VisitElement($forStatementAst.Iterator)
        $newBody = $this.VisitElement($forStatementAst.Body)
        return [ForStatementAst]::new($forStatementAst.Extent, $forStatementAst.Label, $newInitializer, $newCondition, $newIterator, $newBody)
    }

    [object] VisitWhileStatement([WhileStatementAst] $whileStatementAst)
    {
        Write-Host "$(" " * $this.GetDepth($whileStatementAst))i'm in ur whilez"

        $newCondition = $this.VisitElement($whileStatementAst.Condition)
        $newBody = $this.VisitElement($whileStatementAst.Body)
        return [WhileStatementAst]::new($whileStatementAst.Extent, $whileStatementAst.Label, $newCondition, $newBody)
    }

    [object] VisitCatchClause([CatchClauseAst] $catchClauseAst)
    {
        Write-Host "$(" " * $this.GetDepth($catchClauseAst))i'm in ur catchez"

        $newBody = $this.VisitElement($catchClauseAst.Body)
        return [CatchClauseAst]::new($catchClauseAst.Extent, $catchClauseAst.CatchTypes, $newBody)
    }

    [object] VisitTryStatement([TryStatementAst] $tryStatementAst)
    {
        Write-Host "$(" " * $this.GetDepth($tryStatementAst))i'm in ur tryes"

        $newBody = $this.VisitElement($tryStatementAst.Body)
        $newCatchClauses = $this.VisitElements($tryStatementAst.CatchClauses)
        $newFinally = $this.VisitElement($tryStatementAst.Finally)
        return [TryStatementAst]::new($tryStatementAst.Extent, $newBody, $newCatchClauses, $newFinally)
    }

    [object] VisitDoUntilStatement([DoUntilStatementAst] $doUntilStatementAst)
    {
        Write-Host "$(" " * $this.GetDepth($doUntilStatementAst))i'm in ur do-untilz"

        $newCondition = $this.VisitElement($doUntilStatementAst.Condition)
        $newBody = $this.VisitElement($doUntilStatementAst.Body)
        return [DoUntilStatementAst]::new($doUntilStatementAst.Extent, $doUntilStatementAst.Label, $newCondition, $newBody)
    }

    [object] VisitParamBlock([ParamBlockAst] $paramBlockAst)
    {
        Write-Host "$(" " * $this.GetDepth($paramBlockAst))i'm in ur paramz"

        $newAttributes = $this.VisitElements($paramBlockAst.Attributes)
        $newParameters = $this.VisitElements($paramBlockAst.Parameters)
        return [ParamBlockAst]::new($paramBlockAst.Extent, $newAttributes, $newParameters)
    }

    [object] VisitErrorStatement([ErrorStatementAst] $errorStatementAst)
    {
        Write-Host "$(" " * $this.GetDepth($errorStatementAst))i'm in ur error statementz"
        return $errorStatementAst
    }

    [object] VisitErrorExpression([ErrorExpressionAst] $errorExpressionAst)
    {
        return $errorExpressionAst
    }

    [object] VisitTypeConstraint([TypeConstraintAst] $typeConstraintAst)
    {
        Write-Host "$(" " * $this.GetDepth($typeConstraintAst))i'm in ur type-constraintz"

        return [TypeConstraintAst]::new($typeConstraintAst.Extent, $typeConstraintAst.TypeName)
    }

    [object] VisitAttribute([AttributeAst] $attributeAst)
    {
        Write-Host "$(" " * $this.GetDepth($attributeAst))i'm in ur attribz"

        $newPositionalArguments = $this.VisitElements($attributeAst.PositionalArguments)
        $newNamedArguments = $this.VisitElements($attributeAst.NamedArguments)
        return [AttributeAst]::new($attributeAst.Extent, $attributeAst.TypeName, $newPositionalArguments, $newNamedArguments)
    }

    [object] VisitNamedAttributeArgument([NamedAttributeArgumentAst] $namedAttributeArgumentAst)
    {
        Write-Host "$(" " * $this.GetDepth($namedAttributeArgumentAst))i'm in ur named attribz"

        $newArgument = $this.VisitElement($namedAttributeArgumentAst.Argument)
        return [NamedAttributeArgumentAst]::new($namedAttributeArgumentAst.Extent, $namedAttributeArgumentAst.ArgumentName, $newArgument,$namedAttributeArgumentAst.ExpressionOmitted)
    }

    [object] VisitParameter([ParameterAst] $parameterAst)
    {
        Write-Host "$(" " * $this.GetDepth($parameterAst))i'm in ur paramz"

        $newName = $this.VisitElement($parameterAst.Name)
        $newAttributes = $this.VisitElements($parameterAst.Attributes)
        $newDefaultValue = $this.VisitElement($parameterAst.DefaultValue)
        return [ParameterAst]::new($parameterAst.Extent, $newName, $newAttributes, $newDefaultValue)
    }

    [object] VisitBreakStatement([BreakStatementAst] $breakStatementAst)
    {
        Write-Host "$(" " * $this.GetDepth($breakStatementAst))i'm in ur breakz"

        $newLabel = $this.VisitElement($breakStatementAst.Label)
        return [BreakStatementAst]::new($breakStatementAst.Extent, $newLabel)
    }

    [object] VisitContinueStatement([ContinueStatementAst] $continueStatementAst)
    {
        Write-Host "$(" " * $this.GetDepth($continueStatementAst))i'm in ur continuez"

        $newLabel = $this.VisitElement($continueStatementAst.Label)
        return [ContinueStatementAst]::new($continueStatementAst.Extent, $newLabel)
    }

    [object] VisitReturnStatement([ReturnStatementAst] $returnStatementAst)
    {
        Write-Host "$(" " * $this.GetDepth($returnStatementAst))i'm in ur returnz"

        $newPipeline = $this.VisitElement($returnStatementAst.Pipeline)
        return [ReturnStatementAst]::new($returnStatementAst.Extent, $newPipeline)
    }

    [object] VisitExitStatement([ExitStatementAst] $exitStatementAst)
    {
        Write-Host "$(" " * $this.GetDepth($exitStatementAst))i'm in ur exitz"

        $newPipeline = $this.VisitElement($exitStatementAst.Pipeline)
        return [ExitStatementAst]::new($exitStatementAst.Extent, $newPipeline)
    }

    [object] VisitThrowStatement([ThrowStatementAst] $throwStatementAst)
    {
        Write-Host "$(" " * $this.GetDepth($throwStatementAst))i'm in ur throwz"

        $newPipeline = $this.VisitElement($throwStatementAst.Pipeline)
        return [ThrowStatementAst]::new($throwStatementAst.Extent, $newPipeline)
    }

    [object] VisitAssignmentStatement([AssignmentStatementAst] $assignmentStatementAst)
    {
        Write-Host "$(" " * $this.GetDepth($assignmentStatementAst))i'm in ur assignmentz"

        $newLeft = $this.VisitElement($assignmentStatementAst.Left)
        $newRight = $this.VisitElement($assignmentStatementAst.Right)
        return [AssignmentStatementAst]::new($assignmentStatementAst.Extent, $newLeft, $assignmentStatementAst.Operator,$newRight, $assignmentStatementAst.ErrorPosition)
    }

    [object] VisitPipeline([PipelineAst] $pipelineAst)
    {
        Write-Host "$(" " * $this.GetDepth($pipelineAst))i'm in ur pipelinez"

        $newPipeElements = $this.VisitElements($pipelineAst.PipelineElements)
        return [PipelineAst]::new($pipelineAst.Extent, $newPipeElements)
    }

    [object] VisitCommand([CommandAst] $commandAst)
    {
        Write-Host "$(" " * $this.GetDepth($commandAst))i'm in ur commandz"

        $newCommandElements = $this.VisitElements($commandAst.CommandElements)
        $newRedirections = $this.VisitElements($commandAst.Redirections)
        return [CommandAst]::new($commandAst.Extent, $newCommandElements, $commandAst.InvocationOperator, $newRedirections)
    }

    [object] VisitCommandExpression([CommandExpressionAst] $commandExpressionAst)
    {
        Write-Host "$(" " * $this.GetDepth($commandExpressionAst))i'm in ur command exprezz"

        $newExpression = $this.VisitElement($commandExpressionAst.Expression)
        $newRedirections = $this.VisitElements($commandExpressionAst.Redirections)
        return [CommandExpressionAst]::new($commandExpressionAst.Extent, $newExpression, $newRedirections)
    }

    [object] VisitCommandParameter([CommandParameterAst] $commandParameterAst)
    {
        Write-Host "$(" " * $this.GetDepth($commandParameterAst))i'm in ur argumentz"

        $newArgument = $this.VisitElement($commandParameterAst.Argument)
        return [CommandParameterAst]::new($commandParameterAst.Extent, $commandParameterAst.ParameterName, $newArgument, $commandParameterAst.ErrorPosition)
    }

    [object] VisitFileRedirection([FileRedirectionAst] $fileRedirectionAst)
    {
        Write-Host "$(" " * $this.GetDepth($fileRedirectionAst))i'm in ur redirectorz"

        $newFile = $this.VisitElement($fileRedirectionAst.Location)
        return [FileRedirectionAst]::new($fileRedirectionAst.Extent, $fileRedirectionAst.FromStream, $newFile, $fileRedirectionAst.Append)
    }

    [object] VisitMergingRedirection([MergingRedirectionAst] $mergingRedirectionAst)
    {
        Write-Host "$(" " * $this.GetDepth($mergingRedirectionAst))i'm in ur mergez"

        return [MergingRedirectionAst]::new($mergingRedirectionAst.Extent, $mergingRedirectionAst.FromStream, $mergingRedirectionAst.ToStream)
    }

    [object] VisitBinaryExpression([BinaryExpressionAst] $binaryExpressionAst)
    {
        Write-Host "$(" " * $this.GetDepth($binaryExpressionAst))i'm in ur binary $($binaryExpressionAst.Operator) opz"

        $newLeft = $this.VisitElement($binaryExpressionAst.Left)
        $newRight = $this.VisitElement($binaryExpressionAst.Right)
        return [BinaryExpressionAst]::new($binaryExpressionAst.Extent, $newLeft, $binaryExpressionAst.Operator, $newRight, $binaryExpressionAst.ErrorPosition)
    }

    [object] VisitUnaryExpression([UnaryExpressionAst] $unaryExpressionAst)
    {
        Write-Host "$(" " * $this.GetDepth($unaryExpressionAst))i'm in ur unary $($unaryExpressionAst.TokenKind) opz"

        $newChild = $this.VisitElement($unaryExpressionAst.Child)
        return [UnaryExpressionAst]::new($unaryExpressionAst.Extent, $unaryExpressionAst.TokenKind, $newChild)
    }

    [object] VisitConvertExpression([ConvertExpressionAst] $convertExpressionAst)
    {
        Write-Host "$(" " * $this.GetDepth($convertExpressionAst))i'm in ur convertz"

        $newChild = $this.VisitElement($convertExpressionAst.Child)
        $newTypeConstraint = $this.VisitElement($convertExpressionAst.Type)
        return [ConvertExpressionAst]::new($convertExpressionAst.Extent, $newTypeConstraint, $newChild)
    }

    [object] VisitTypeExpression([TypeExpressionAst] $typeExpressionAst)
    {
        Write-Host "$(" " * $this.GetDepth($typeExpressionAst))i'm in ur $($typeExpressionAst.TypeName) typez"

        return [TypeExpressionAst]::new($typeExpressionAst.Extent, $typeExpressionAst.TypeName)
    }

    [object] VisitConstantExpression([ConstantExpressionAst] $constantExpressionAst)
    {
        Write-Host "$(" " * $this.GetDepth($constantExpressionAst))i'm in ur ""$($constantExpressionAst.Value)"" constantz"

        return [ConstantExpressionAst]::new($constantExpressionAst.Extent, $constantExpressionAst.Value)
    }

    [object] VisitStringConstantExpression([StringConstantExpressionAst] $stringConstantExpressionAst)
    {
        Write-Host "$(" " * $this.GetDepth($stringConstantExpressionAst))i'm in ur ""$($stringConstantExpressionAst.Value)"" string constantz"
        return [StringConstantExpressionAst]::new($stringConstantExpressionAst.Extent, $stringConstantExpressionAst.Value, $stringConstantExpressionAst.StringConstantType)
    }

    [object] VisitSubExpression([SubExpressionAst] $subExpressionAst)
    {
        Write-Host "$(" " * $this.GetDepth($subExpressionAst))i'm in ur subexprezz"
        $newStatementBlock = $this.VisitElement($subExpressionAst.SubExpression)
        return [SubExpressionAst]::new($subExpressionAst.Extent, $newStatementBlock)
    }

    [object] VisitUsingExpression([UsingExpressionAst] $usingExpressionAst)
    {
        Write-Host "$(" " * $this.GetDepth($usingExpressionAst))i'm in ur usingz"
        $newUsingExpr = $this.VisitElement($usingExpressionAst.SubExpression)
        return [UsingExpressionAst]::new($usingExpressionAst.Extent, $newUsingExpr)
    }

    [object] VisitVariableExpression([VariableExpressionAst] $variableExpressionAst)
    {
        Write-Host "$(" " * $this.GetDepth($variableExpressionAst))i'm in ur variablez"
        return [VariableExpressionAst]::new($variableExpressionAst.Extent, $variableExpressionAst.VariablePath.UserPath, $variableExpressionAst.Splatted)
    }

    [object] VisitMemberExpression([MemberExpressionAst] $memberExpressionAst)
    {
        Write-Host "$(" " * $this.GetDepth($memberExpressionAst))i'm in ur member refz"
        $newExpr = $this.VisitElement($memberExpressionAst.Expression)
        $newMember = $this.VisitElement($memberExpressionAst.Member)
        return [MemberExpressionAst]::new($memberExpressionAst.Extent, $newExpr, $newMember, $memberExpressionAst.Static)
    }

    [object] VisitInvokeMemberExpression([InvokeMemberExpressionAst] $invokeMemberExpressionAst)
    {
        Write-Host "$(" " * $this.GetDepth($invokeMemberExpressionAst))i'm in ur invoke-member exprezz"
        $newExpression = $this.VisitElement($invokeMemberExpressionAst.Expression)
        $newMethod = $this.VisitElement($invokeMemberExpressionAst.Member)
        $newArguments = $this.VisitElements($invokeMemberExpressionAst.Arguments)
        return [InvokeMemberExpressionAst]::new($invokeMemberExpressionAst.Extent, $newExpression, $newMethod, $newArguments, $invokeMemberExpressionAst.Static)
    }

    [object] VisitArrayExpression([ArrayExpressionAst] $arrayExpressionAst)
    {
        Write-Host "$(" " * $this.GetDepth($arrayExpressionAst))i'm in ur array exprezz"
        $newStatementBlock = $this.VisitElement($arrayExpressionAst.SubExpression)
        return [ArrayExpressionAst]::new($arrayExpressionAst.Extent, $newStatementBlock)
    }

    [object] VisitArrayLiteral([ArrayLiteralAst] $arrayLiteralAst)
    {
        Write-Host "$(" " * $this.GetDepth($arrayLiteralAst))i'm in ur array literalz"
        $newArrayElements = $this.VisitElements($arrayLiteralAst.Elements)
        return [ArrayLiteralAst]::new($arrayLiteralAst.Extent, $newArrayElements)
    }

    [object] VisitHashtable([HashtableAst] $hashtableAst)
    {
        Write-Host "$(" " * $this.GetDepth($hashtableAst))i'm in ur array hashtablez"
        $newKeyValuePairs = [List[Tuple[ExpressionAst,StatementAst]]]::new()
        foreach ($keyValuePair in $hashtableAst.KeyValuePairs)
        {
            $newKey = $this.VisitElement($keyValuePair.Item1);
            $newValue = $this.VisitElement($keyValuePair.Item2);
            $newKeyValuePairs.Add([Tuple[ExpressionAst,StatementAst]]::new($newKey, $newValue)) # TODO NOT SURE
        }
        return [HashtableAst]::new($hashtableAst.Extent, $newKeyValuePairs)
    }

    [object] VisitScriptBlockExpression([ScriptBlockExpressionAst] $scriptBlockExpressionAst)
    {
        Write-Host "$(" " * $this.GetDepth($scriptBlockExpressionAst))i'm in ur array script block exprezz"
        $newScriptBlock = $this.VisitElement($scriptBlockExpressionAst.ScriptBlock)
        return [ScriptBlockExpressionAst]::new($scriptBlockExpressionAst.Extent, $newScriptBlock)
    }

    [object] VisitParenExpression([ParenExpressionAst] $parenExpressionAst)
    {
        Write-Host "$(" " * $this.GetDepth($parenExpressionAst))i'm in ur array parenthesez"
        $newPipeline = $this.VisitElement($parenExpressionAst.Pipeline)
        return [ParenExpressionAst]::new($parenExpressionAst.Extent, $newPipeline)
    }

    [object] VisitExpandableStringExpression([ExpandableStringExpressionAst] $expandableStringExpressionAst)
    {
        Write-Host "$(" " * $this.GetDepth($expandableStringExpressionAst))i'm in ur array expandable stringz"
        return [ExpandableStringExpressionAst]::new($expandableStringExpressionAst.Extent,$expandableStringExpressionAst.Value,$expandableStringExpressionAst.StringConstantType)
    }

    [object] VisitIndexExpression([IndexExpressionAst] $indexExpressionAst)
    {
        Write-Host "$(" " * $this.GetDepth($indexExpressionAst))i'm in ur array index exprezz"
        $newTargetExpression = $this.VisitElement($indexExpressionAst.Target)
        $newIndexExpression = $this.VisitElement($indexExpressionAst.Index)
        return [IndexExpressionAst]::new($indexExpressionAst.Extent, $newTargetExpression, $newIndexExpression)
    }

    [object] VisitAttributedExpression([AttributedExpressionAst] $attributedExpressionAst)
    {
        Write-Host "$(" " * $this.GetDepth($attributedExpressionAst))i'm in ur attrib exprezz"
        $newAttribute = $this.VisitElement($attributedExpressionAst.Attribute)
        $newChild = $this.VisitElement($attributedExpressionAst.Child)
        return [AttributedExpressionAst]::new($attributedExpressionAst.Extent, $newAttribute, $newChild)
    }

    [object] VisitBlockStatement([BlockStatementAst] $blockStatementAst)
    {
        Write-Host "$(" " * $this.GetDepth($blockStatementAst))i'm in ur array blockz"
        $newBody = $this.VisitElement($blockStatementAst.Body)
        return [BlockStatementAst]::new($blockStatementAst.Extent, $blockStatementAst.Kind, $newBody)
    }
}
#endregion