WIP: Possible alternate implementation of UseConsistentWhitespace CheckOperator feature

Engine/FindAstPositionVisitor.cs

@@ -0,0 +1,369 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System.Management.Automation.Language;
+
+namespace Microsoft.Windows.PowerShell.ScriptAnalyzer
+{
+    /// <summary>
+    /// Provides an efficient way to find the position in the AST corresponding to a given script position.
+    /// </summary>
+#if !(PSV3 || PSV4)
+    internal class FindAstPositionVisitor : AstVisitor2
+#else
+    internal class FindAstPositionVisitor : AstVisitor
+#endif
+    {
+        private IScriptPosition searchPosition;
+
+        /// <summary>
+        /// Contains the position in the AST corresponding to the provided <see cref="IScriptPosition"/> upon completion of the <see cref="Ast.Visit(AstVisitor)"/> method.
+        /// </summary>
+        public Ast AstPosition { get; private set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FindAstPositionVisitor"/> class with the postition to search for.
+        /// </summary>
+        /// <param name="position">The script position to search for.</param>
+        public FindAstPositionVisitor(IScriptPosition position)
+        {
+            this.searchPosition = position;
+        }
+
+        /// <summary>
+        /// Traverses the AST based on offests to find the leaf node which contains the provided <see cref="IScriptPosition"/>.
+        /// This method implements the entire functionality of this visitor. All <see cref="AstVisitor2"/> methods are overridden to simply invoke this one.
+        /// </summary>
+        /// <param name="ast">Current AST node to process.</param>
+        /// <returns>An <see cref="AstVisitAction"/> indicating whether to visit children of the current node.</returns>
+        private AstVisitAction Visit(Ast ast)
+        {
+            if (ast.Extent.StartOffset > searchPosition.Offset || ast.Extent.EndOffset <= searchPosition.Offset)
+            {
+                return AstVisitAction.SkipChildren;
+            }
+            AstPosition = ast;
+            return AstVisitAction.Continue;
+        }
+
+         public override AstVisitAction VisitArrayExpression(ArrayExpressionAst arrayExpressionAst)
+         {
+             return Visit(arrayExpressionAst);
+         }
+
+         public override AstVisitAction VisitArrayLiteral(ArrayLiteralAst arrayLiteralAst)
+         {
+             return Visit(arrayLiteralAst);
+         }
+
+         public override AstVisitAction VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst)
+         {
+             return Visit(assignmentStatementAst);
+         }
+
+         public override AstVisitAction VisitAttribute(AttributeAst attributeAst)
+         {
+             return Visit(attributeAst);
+         }
+
+         public override AstVisitAction VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)
+         {
+             return Visit(attributedExpressionAst);
+         }
+
+         public override AstVisitAction VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
+         {
+             return Visit(binaryExpressionAst);
+         }
+
+         public override AstVisitAction VisitBlockStatement(BlockStatementAst blockStatementAst)
+         {
+             return Visit(blockStatementAst);
+         }
+
+         public override AstVisitAction VisitBreakStatement(BreakStatementAst breakStatementAst)
+         {
+             return Visit(breakStatementAst);
+         }
+
+         public override AstVisitAction VisitCatchClause(CatchClauseAst catchClauseAst)
+         {
+             return Visit(catchClauseAst);
+         }
+
+         public override AstVisitAction VisitCommand(CommandAst commandAst)
+         {
+             return Visit(commandAst);
+         }
+
+         public override AstVisitAction VisitCommandExpression(CommandExpressionAst commandExpressionAst)
+         {
+             return Visit(commandExpressionAst);
+         }
+
+         public override AstVisitAction VisitCommandParameter(CommandParameterAst commandParameterAst)
+         {
+             return Visit(commandParameterAst);
+         }
+
+         public override AstVisitAction VisitConstantExpression(ConstantExpressionAst constantExpressionAst)
+         {
+             return Visit(constantExpressionAst);
+         }
+
+         public override AstVisitAction VisitContinueStatement(ContinueStatementAst continueStatementAst)
+         {
+             return Visit(continueStatementAst);
+         }
+
+         public override AstVisitAction VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
+         {
+             return Visit(convertExpressionAst);
+         }
+
+         public override AstVisitAction VisitDataStatement(DataStatementAst dataStatementAst)
+         {
+             return Visit(dataStatementAst);
+         }
+
+         public override AstVisitAction VisitDoUntilStatement(DoUntilStatementAst doUntilStatementAst)
+         {
+             return Visit(doUntilStatementAst);
+         }
+
+         public override AstVisitAction VisitDoWhileStatement(DoWhileStatementAst doWhileStatementAst)
+         {
+             return Visit(doWhileStatementAst);
+         }
+
+         public override AstVisitAction VisitErrorExpression(ErrorExpressionAst errorExpressionAst)
+         {
+             return Visit(errorExpressionAst);
+         }
+
+         public override AstVisitAction VisitErrorStatement(ErrorStatementAst errorStatementAst)
+         {
+             return Visit(errorStatementAst);
+         }
+
+         public override AstVisitAction VisitExitStatement(ExitStatementAst exitStatementAst)
+         {
+             return Visit(exitStatementAst);
+         }
+
+         public override AstVisitAction VisitExpandableStringExpression(ExpandableStringExpressionAst expandableStringExpressionAst)
+         {
+             return Visit(expandableStringExpressionAst);
+         }
+
+         public override AstVisitAction VisitFileRedirection(FileRedirectionAst fileRedirectionAst)
+         {
+             return Visit(fileRedirectionAst);
+         }
+
+         public override AstVisitAction VisitForEachStatement(ForEachStatementAst forEachStatementAst)
+         {
+             return Visit(forEachStatementAst);
+         }
+
+         public override AstVisitAction VisitForStatement(ForStatementAst forStatementAst)
+         {
+             return Visit(forStatementAst);
+         }
+
+         public override AstVisitAction VisitFunctionDefinition(FunctionDefinitionAst functionDefinitionAst)
+         {
+             return Visit(functionDefinitionAst);
+         }
+
+         public override AstVisitAction VisitHashtable(HashtableAst hashtableAst)
+         {
+             return Visit(hashtableAst);
+         }
+
+         public override AstVisitAction VisitIfStatement(IfStatementAst ifStatementAst)
+         {
+             return Visit(ifStatementAst);
+         }
+
+         public override AstVisitAction VisitIndexExpression(IndexExpressionAst indexExpressionAst)
+         {
+             return Visit(indexExpressionAst);
+         }
+
+         public override AstVisitAction VisitInvokeMemberExpression(InvokeMemberExpressionAst invokeMemberExpressionAst)
+         {
+             return Visit(invokeMemberExpressionAst);
+         }
+
+         public override AstVisitAction VisitMemberExpression(MemberExpressionAst memberExpressionAst)
+         {
+             return Visit(memberExpressionAst);
+         }
+
+         public override AstVisitAction VisitMergingRedirection(MergingRedirectionAst mergingRedirectionAst)
+         {
+             return Visit(mergingRedirectionAst);
+         }
+
+         public override AstVisitAction VisitNamedAttributeArgument(NamedAttributeArgumentAst namedAttributeArgumentAst)
+         {
+             return Visit(namedAttributeArgumentAst);
+         }
+
+         public override AstVisitAction VisitNamedBlock(NamedBlockAst namedBlockAst)
+         {
+             return Visit(namedBlockAst);
+         }
+
+         public override AstVisitAction VisitParamBlock(ParamBlockAst paramBlockAst)
+         {
+             return Visit(paramBlockAst);
+         }
+
+         public override AstVisitAction VisitParameter(ParameterAst parameterAst)
+         {
+             return Visit(parameterAst);
+         }
+
+         public override AstVisitAction VisitParenExpression(ParenExpressionAst parenExpressionAst)
+         {
+             return Visit(parenExpressionAst);
+         }
+
+         public override AstVisitAction VisitPipeline(PipelineAst pipelineAst)
+         {
+             return Visit(pipelineAst);
+         }
+
+         public override AstVisitAction VisitReturnStatement(ReturnStatementAst returnStatementAst)
+         {
+             return Visit(returnStatementAst);
+         }
+
+         public override AstVisitAction VisitScriptBlock(ScriptBlockAst scriptBlockAst)
+         {
+             return Visit(scriptBlockAst);
+         }
+
+         public override AstVisitAction VisitScriptBlockExpression(ScriptBlockExpressionAst scriptBlockExpressionAst)
+         {
+             return Visit(scriptBlockExpressionAst);
+         }
+
+         public override AstVisitAction VisitStatementBlock(StatementBlockAst statementBlockAst)
+         {
+             return Visit(statementBlockAst);
+         }
+
+         public override AstVisitAction VisitStringConstantExpression(StringConstantExpressionAst stringConstantExpressionAst)
+         {
+             return Visit(stringConstantExpressionAst);
+         }
+
+         public override AstVisitAction VisitSubExpression(SubExpressionAst subExpressionAst)
+         {
+             return Visit(subExpressionAst);
+         }
+
+         public override AstVisitAction VisitSwitchStatement(SwitchStatementAst switchStatementAst)
+         {
+             return Visit(switchStatementAst);
+         }
+
+         public override AstVisitAction VisitThrowStatement(ThrowStatementAst throwStatementAst)
+         {
+             return Visit(throwStatementAst);
+         }
+
+         public override AstVisitAction VisitTrap(TrapStatementAst trapStatementAst)
+         {
+             return Visit(trapStatementAst);
+         }
+
+         public override AstVisitAction VisitTryStatement(TryStatementAst tryStatementAst)
+         {
+             return Visit(tryStatementAst);
+         }
+
+         public override AstVisitAction VisitTypeConstraint(TypeConstraintAst typeConstraintAst)
+         {
+             return Visit(typeConstraintAst);
+         }
+
+         public override AstVisitAction VisitTypeExpression(TypeExpressionAst typeExpressionAst)
+         {
+             return Visit(typeExpressionAst);
+         }
+
+         public override AstVisitAction VisitUnaryExpression(UnaryExpressionAst unaryExpressionAst)
+         {
+             return Visit(unaryExpressionAst);
+         }
+
+         public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst)
+         {
+             return Visit(usingExpressionAst);
+         }
+
+         public override AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst)
+         {
+             return Visit(variableExpressionAst);
+         }
+
+         public override AstVisitAction VisitWhileStatement(WhileStatementAst whileStatementAst)
+         {
+             return Visit(whileStatementAst);
+         }
+
+#if !(PSV3 || PSV4)
+         public override AstVisitAction VisitBaseCtorInvokeMemberExpression(BaseCtorInvokeMemberExpressionAst baseCtorInvokeMemberExpressionAst)
+         {
+             return Visit(baseCtorInvokeMemberExpressionAst);
+         }
+
+         public override AstVisitAction VisitConfigurationDefinition(ConfigurationDefinitionAst configurationDefinitionAst)
+         {
+             return Visit(configurationDefinitionAst);
+         }
+
+         public override AstVisitAction VisitDynamicKeywordStatement(DynamicKeywordStatementAst dynamicKeywordStatementAst)
+         {
+             return Visit(dynamicKeywordStatementAst);
+         }
+
+         public override AstVisitAction VisitFunctionMember(FunctionMemberAst functionMemberAst)
+         {
+             return Visit(functionMemberAst);
+         }
+
+         public override AstVisitAction VisitPropertyMember(PropertyMemberAst propertyMemberAst)
+         {
+             return Visit(propertyMemberAst);
+         }
+
+         public override AstVisitAction VisitTypeDefinition(TypeDefinitionAst typeDefinitionAst)
+         {
+             return Visit(typeDefinitionAst);
+         }
+
+         public override AstVisitAction VisitUsingStatement(UsingStatementAst usingStatementAst)
+         {
+             return Visit(usingStatementAst);
+         }
+#endif
+
+#if !(NET452 || PSV6) // NET452 includes V3,4,5
+         public override AstVisitAction VisitPipelineChain(PipelineChainAst pipelineChainAst)
+         {
+             return Visit(pipelineChainAst);
+         }
+
+         public override AstVisitAction VisitTernaryExpression(TernaryExpressionAst ternaryExpressionAst)
+         {
+             return Visit(ternaryExpressionAst);
+         }
+#endif
+
+    }
+}

Engine/TokenOperations.cs

@@ -232,5 +232,18 @@ private bool OnSameLine(Token token1, Token token2)
         {
             return token1.Extent.StartLineNumber == token2.Extent.EndLineNumber;
         }
+
+        /// <summary>
+        /// Finds the position of a given token in the AST.
+        /// </summary>
+        /// <param name="token">The <see cref="Token"/> to search for.</param>
+        /// <returns>The Ast node directly containing the provided <see cref="Token"/>.</returns>
+        public Ast GetAstPosition(Token token)
+        {
+            FindAstPositionVisitor findAstVisitor = new FindAstPositionVisitor(token.Extent.StartScriptPosition);
+            ast.Visit(findAstVisitor);
+            return findAstVisitor.AstPosition;
+        }
+
     }
 }