                     guard let previousConsumedToken = previousUsedToken where !previousConsumedToken.isWhitespace() else {
                         break postfixLoop
                     }
-                    for _ in 0..<remainingTokens.count-skipWhitespacesForTokens(remainingTokens).count {
-                        previousUsedToken = remainingHeadToken
-                        remainingHeadToken = remainingTokens.popLast()
-                    }
-                    previousUsedToken = remainingHeadToken
-                    remainingHeadToken = remainingTokens.popLast()
-
+                    __skipWhitespacesAndPreservePreviousToken(&remainingTokens, &remainingHeadToken, &previousUsedToken)
                     resultExpression = ForcedValueExpression(postfixExpression: resultExpression)
                 case .Question:
                     guard let previousConsumedToken = previousUsedToken where !previousConsumedToken.isWhitespace() else {
                         break postfixLoop
                     }
-                    for _ in 0..<remainingTokens.count-skipWhitespacesForTokens(remainingTokens).count {
-                        previousUsedToken = remainingHeadToken
-                        remainingHeadToken = remainingTokens.popLast()
-                    }
-                    previousUsedToken = remainingHeadToken
-                    remainingHeadToken = remainingTokens.popLast()
-
+                    __skipWhitespacesAndPreservePreviousToken(&remainingTokens, &remainingHeadToken, &previousUsedToken)
                     resultExpression = OptionalChainingExpression(postfixExpression: resultExpression)
                 default:
                     break postfixLoop
                 }
             case .Operator(let operatorString):
-                for _ in 0..<remainingTokens.count-skipWhitespacesForTokens(remainingTokens).count {
-                    previousUsedToken = remainingHeadToken
-                    remainingHeadToken = remainingTokens.popLast()
-                }
-                previousUsedToken = remainingHeadToken
-                remainingHeadToken = remainingTokens.popLast()
-
+                __skipWhitespacesAndPreservePreviousToken(&remainingTokens, &remainingHeadToken, &previousUsedToken)
                 resultExpression = PostfixOperatorExpression(
                     postfixOperator: operatorString, postfixExpression: resultExpression)
             default:

            }
        }

        // explicit member expression
        let parseIdExprResult = _parseIdentifierExpression(remainingHeadToken, tokens: remainingTokens)
        if parseIdExprResult.hasResult {
            for _ in 0..<parseIdExprResult.advancedBy {
                remainingHeadToken = remainingTokens.popLast()
            }
            return ParsingResult<PostfixExpression>.makeResult(
                ExplicitMemberExpression.makeNamedTypeExplicitMemberExpression(resultExpression, parseIdExprResult.result),
                tokens.count - remainingTokens.count)
        }
        let parseLiteralExprResult = _parseLiteralExpression(remainingHeadToken, tokens: remainingTokens)
        if let integerLiteralExpr = parseLiteralExprResult.result as? IntegerLiteralExpression
        where parseLiteralExprResult.hasResult && integerLiteralExpr.kind == .Decimal {
            for _ in 0..<parseLiteralExprResult.advancedBy {
                remainingHeadToken = remainingTokens.popLast()
            }
            return ParsingResult<PostfixExpression>.makeResult(
                ExplicitMemberExpression.makeTupleExplicitMemberExpression(resultExpression, integerLiteralExpr),
                tokens.count - remainingTokens.count)
        }

        return ParsingResult<PostfixExpression>.makeNoResult()
    }


                    guard parseDotPostfixExprResult.hasResult else {
                        break postfixLoop
                    }
                    __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
                    }
                    __advancedTokensAndPreservePreviousToken(
                        parsingExpressionListResult.advancedBy, &remainingTokens, &remainingHeadToken, &previousUsedToken)
                    if let closingToken = remainingHeadToken, case let .Punctuator(punctuatorType) = closingToken
                    where punctuatorType == .RightSquare {
                        __skipWhitespacesAndPreservePreviousToken(&remainingTokens, &remainingHeadToken, &previousUsedToken)
                        resultExpression = SubscriptExpression(
                            postfixExpression: resultExpression, indexExpressions: parsingExpressionListResult.result)
                    }
