fix: Unary Postfix Operations require whitespace skips

Author: DrSkillIssue

Rules/UseConsistentWhitespace.cs

@@ -569,14 +569,14 @@ private IEnumerable<DiagnosticRecord> FindParameterViolations(Ast ast)
                     bool isInsideString = false;
                     foreach (var stringAst in stringAsts)
                     {
-                        if (stringAst.Extent.StartOffset < leftExtent.EndOffset && 
+                        if (stringAst.Extent.StartOffset < leftExtent.EndOffset &&
                             stringAst.Extent.EndOffset > rightExtent.StartOffset)
                         {
                             isInsideString = true;
                             break;
                         }
                     }
-                    
+
                     if (isInsideString)
                     {
                         continue;
@@ -633,7 +633,7 @@ private IEnumerable<DiagnosticRecord> FindSeparatorViolations(TokenOperations to
                     {
                         var prevTok = tokenNode.Previous.Value;
                         var nextTok = tokenNode.Next.Value;
-                        
+
                         // Skip if comma appears to be within a parameter value (no spaces around it)
                         if ((prevTok.Kind == TokenKind.Identifier || prevTok.Kind == TokenKind.Generic) &&
                             (nextTok.Kind == TokenKind.Identifier || nextTok.Kind == TokenKind.Generic) &&
@@ -766,53 +766,49 @@ private IEnumerable<DiagnosticRecord> FindOperatorViolations(TokenOperations tok
                     continue;
                 }
 
-                if (tokenNode.Previous == null || tokenNode.Next == null || token.Kind == TokenKind.DotDot)
+                var skipNullOrDotDot = tokenNode.Previous == null ||
+                    tokenNode.Next == null ||
+                    token.Kind == TokenKind.DotDot;
+
+                if (skipNullOrDotDot)
                 {
                     continue;
                 }
 
-                // Check unary operator handling
-                bool isUnaryInMethodCall = false;
-                if (TokenTraits.HasTrait(token.Kind, TokenFlags.UnaryOperator))
+                // Exclude assignment operator inside of multi-line hash tables if requested
+                if (IgnoreAssignmentOperatorInsideHashTable && tokenNode.Value.Kind == TokenKind.Equals)
                 {
-                    // Only skip if it's a unary operator in a method call like $foo.bar(-$var)
-                    if (tokenNode.Previous.Value.Kind == TokenKind.LParen &&
-                        tokenNode.Next.Value.Kind == TokenKind.Variable &&
-                        tokenNode.Previous.Previous != null)
+                    Ast containingAst = tokenOperations.GetAstPosition(tokenNode.Value);
+                    if (containingAst is HashtableAst && containingAst.Extent.EndLineNumber != containingAst.Extent.StartLineNumber)
                     {
-                        var beforeLParen = tokenNode.Previous.Previous.Value;
-                        isUnaryInMethodCall = beforeLParen.Kind == TokenKind.Dot ||
-                                    (beforeLParen.TokenFlags & TokenFlags.MemberName) == TokenFlags.MemberName;
+                        continue;
                     }
                 }
 
-                if (isUnaryInMethodCall)
-                {
-                    continue;
-                }
+                var isUnaryOperator = TokenTraits.HasTrait(token.Kind, TokenFlags.UnaryOperator);
 
-                // exclude assignment operator inside of multi-line hash tables if requested
-                if (IgnoreAssignmentOperatorInsideHashTable && tokenNode.Value.Kind == TokenKind.Equals)
+                // Check if we can skip Unary Method invocations or Unary Postfix invocations
+                // E.g., someObject.method(-$variable) or $A++, $B++
+                if (isUnaryOperator)
                 {
-                    Ast containingAst = tokenOperations.GetAstPosition(tokenNode.Value);
-                    if (containingAst is HashtableAst && containingAst.Extent.EndLineNumber != containingAst.Extent.StartLineNumber)
+                    if (IsUnaryOperatorInMethodCall(tokenNode) || IsUnaryPostfixOperator(tokenNode))
                     {
                         continue;
                     }
                 }
 
-                // Check whitespace
+                // Check for 'before' and 'after' whitespaces
                 var hasWhitespaceBefore = IsPreviousTokenOnSameLineAndApartByWhitespace(tokenNode);
-                var hasWhitespaceAfter = tokenNode.Next.Value.Kind == TokenKind.NewLine ||
-                                        IsPreviousTokenOnSameLineAndApartByWhitespace(tokenNode.Next);
 
-                // Special case: Don't require space before unary operator if preceded by LParen
-                if (TokenTraits.HasTrait(token.Kind, TokenFlags.UnaryOperator) &&
-                    tokenNode.Previous.Value.Kind == TokenKind.LParen)
+                if (!hasWhitespaceBefore && isUnaryOperator)
                 {
-                    hasWhitespaceBefore = true;
+                    // Special case: Don't require space before unary operator if preceded by LParen
+                    hasWhitespaceBefore = IsPreviousTokenLParen(tokenNode);
                 }
 
+                var hasWhitespaceAfter = tokenNode.Next.Value.Kind == TokenKind.NewLine ||
+                    IsPreviousTokenOnSameLineAndApartByWhitespace(tokenNode.Next);
+
                 if (!hasWhitespaceAfter || !hasWhitespaceBefore)
                 {
                     yield return new DiagnosticRecord(
@@ -832,6 +828,46 @@ private IEnumerable<DiagnosticRecord> FindOperatorViolations(TokenOperations tok
             }
         }
 
+        private bool IsUnaryOperatorInMethodCall(LinkedListNode<Token> tokenNode)
+        {
+            var prevToken = tokenNode.Previous;
+
+            if (prevToken == null || prevToken.Previous == null)
+            {
+                return false;
+            }
+
+            if (!IsPreviousTokenLParen(tokenNode) || tokenNode.Next?.Value.Kind != TokenKind.Variable)
+            {
+                return false;
+            }
+
+            var tokenBeforeLParam = prevToken.Previous.Value;
+
+            // Pattern: someObject.method(-$variable)
+            return tokenBeforeLParam.Kind == TokenKind.Dot ||
+                (tokenBeforeLParam.TokenFlags & TokenFlags.MemberName) == TokenFlags.MemberName;
+        }
+
+        private bool IsUnaryPostfixOperator(LinkedListNode<Token> tokenNode)
+        {
+            var token = tokenNode.Value;
+
+            if (token.Kind != TokenKind.PlusPlus && token.Kind != TokenKind.MinusMinus)
+            {
+                return false;
+            }
+
+            // Postfix operators come after variables, identifiers, or closing brackets/parentheses
+            var prevToken = tokenNode.Previous.Value;
+
+            return prevToken.Kind == TokenKind.Variable ||
+                   prevToken.Kind == TokenKind.Identifier ||
+                   prevToken.Kind == TokenKind.RBracket ||  // for array access like $arr[0]++
+                   prevToken.Kind == TokenKind.RParen ||    // for expressions like ($x)++
+                   (prevToken.TokenFlags & TokenFlags.MemberName) == TokenFlags.MemberName;
+        }
+
         private List<CorrectionExtent> GetCorrections(
             Token prevToken,
             Token token,