                     guard parseDotPostfixExprResult.hasResult else {
                         break postfixLoop
                     }
-                    for _ in 0..<parseDotPostfixExprResult.advancedBy {
-                        previousUsedToken = remainingHeadToken
-                        remainingHeadToken = remainingTokens.popLast()
-                    }
-
+                    __advancedTokensAndPreservePreviousToken(
+                        parseDotPostfixExprResult.advancedBy, &remainingTokens, &remainingHeadToken, &previousUsedToken)
                     resultExpression = parseDotPostfixExprResult.result
                 case .LeftSquare:
                     remainingTokens = skipWhitespacesForTokens(remainingTokens)
                     remainingHeadToken = remainingTokens.popLast()
 
                     let parsingExpressionListResult = _parseExpressionList(remainingHeadToken, tokens: remainingTokens)
-                    guard parsingExpressionListResult.hasResult  else {
-                        break postfixLoop
-                    }
-                    for _ in 0..<parsingExpressionListResult.advancedBy {
-                        remainingHeadToken = remainingTokens.popLast()
-                    }
-
+                    guard parsingExpressionListResult.hasResult else {
+                        break postfixLoop
+                    }
+                    __advancedTokensAndPreservePreviousToken(
+                        parsingExpressionListResult.advancedBy, &remainingTokens, &remainingHeadToken, &previousUsedToken)
                     if let closingToken = remainingHeadToken, case let .Punctuator(punctuatorType) = closingToken
                     where punctuatorType == .RightSquare {
-                        for _ in 0..<remainingTokens.count-skipWhitespacesForTokens(remainingTokens).count {
-                            previousUsedToken = remainingHeadToken
-                            remainingHeadToken = remainingTokens.popLast()
-                        }
-                        previousUsedToken = remainingHeadToken
-                        remainingHeadToken = remainingTokens.popLast()
-
+                        __skipWhitespacesAndPreservePreviousToken(&remainingTokens, &remainingHeadToken, &previousUsedToken)
                         resultExpression = SubscriptExpression(
                             postfixExpression: resultExpression, indexExpressions: parsingExpressionListResult.result)
                     }

                    guard parseParenExprResult.hasResult else {
                        break postfixLoop
                    }
                    for _ in 0..<parseParenExprResult.advancedBy {
                        previousUsedToken = remainingHeadToken
                        remainingHeadToken = remainingTokens.popLast()
                    }

                    resultExpression = FunctionCallExpression.makeParenthesizedFunctionCallExpression(resultExpression, parseParenExprResult.result)
                case .Period:
                    remainingTokens = skipWhitespacesForTokens(remainingTokens)

                    guard let previousConsumedToken = previousUsedToken where !previousConsumedToken.isWhitespace() else {
                        break postfixLoop
                    }
                    __skipWhitespacesAndPreservePreviousToken(&remainingTokens, &remainingHeadToken, &previousUsedToken)
                    resultExpression = ForcedValueExpression(postfixExpression: resultExpression)
                case .Question:
                    guard let previousConsumedToken = previousUsedToken where !previousConsumedToken.isWhitespace() else {
                        break postfixLoop
                    }
                    __skipWhitespacesAndPreservePreviousToken(&remainingTokens, &remainingHeadToken, &previousUsedToken)
                    resultExpression = OptionalChainingExpression(postfixExpression: resultExpression)
                default:
                    break postfixLoop
                }
            case .Operator(let operatorString):
                __skipWhitespacesAndPreservePreviousToken(&remainingTokens, &remainingHeadToken, &previousUsedToken)
                resultExpression = PostfixOperatorExpression(
                    postfixOperator: operatorString, postfixExpression: resultExpression)
            default:
