             }
         }
 
-        // 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 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()

                    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()

                    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()

                resultExpression = PostfixOperatorExpression(
                    postfixOperator: operatorString, postfixExpression: resultExpression)
            default:

        return ParsingResult<PostfixExpression>.makeResult(resultExpression, tokens.count - remainingTokens.count)
    }

    private func __skipWhitespacesAndPreservePreviousToken( // method with side effect
        inout remainingTokens: [Token], inout _ remainingHeadToken: Token?, inout _ previousUsedToken: Token?) {
        __advancedTokensAndPreservePreviousToken(
            remainingTokens.count - skipWhitespacesForTokens(remainingTokens).count + 1,
            &remainingTokens,
            &remainingHeadToken,
            &previousUsedToken)
    }

    private func __advancedTokensAndPreservePreviousToken( // method with side effect
        advancedBy: Int,
        inout _ remainingTokens: [Token],
        inout _ remainingHeadToken: Token?,
        inout _ previousUsedToken: Token?) {
        for _ in 0..<advancedBy {
            previousUsedToken = remainingHeadToken
            remainingHeadToken = remainingTokens.popLast()
        }
    }

    private func _parseDotPostfixExpression(
        head: Token?,
        tokens: [Token],
        postfixExpression resultExpression: PostfixExpression) -> ParsingResult<PostfixExpression> {
        let parseDotKeywordPostfixExpressionResult = _parseDotKeywordPostfixExpression(
            head, tokens: tokens, postfixExpression: resultExpression)
        if parseDotKeywordPostfixExpressionResult.hasResult {
            return parseDotKeywordPostfixExpressionResult
        }

        return _parseExplicitMemberExpression(head, tokens: tokens, postfixExpression: resultExpression)
    }

    private func _parseExplicitMemberExpression(head: Token?,
        tokens: [Token],
        postfixExpression resultExpression: PostfixExpression) -> ParsingResult<PostfixExpression> {
        var remainingTokens = tokens
        var remainingHeadToken: Token? = head

        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()
    }

    private func _parseDotKeywordPostfixExpression(
        head: Token?,
        tokens: [Token],
        postfixExpression resultExpression: PostfixExpression) -> ParsingResult<PostfixExpression> {
        var remainingTokens = tokens
        var remainingHeadToken: Token? = head

        if let currentHeadToken = remainingHeadToken, case let .Keyword(keywordStr, _) = currentHeadToken
        where keywordStr == "init" || keywordStr == "self" || keywordStr == "dynamicType" {
            remainingTokens = skipWhitespacesForTokens(remainingTokens)
