protected override ITreeNode ExpandPostfix(PostfixExpressionContext context)
        {
            var csharpContext = (CSharpPostfixExpressionContext)context;
            var psiModule     = csharpContext.PostfixContext.PsiModule;
            var psiServices   = psiModule.GetPsiServices();
            var factory       = CSharpElementFactory.GetInstance(psiModule);

            var targetStatement = csharpContext.GetContainingStatement();
            var expressionRange = csharpContext.Expression.GetDocumentRange();

            // Razor issue - hard to convert expression to statement
            if (!targetStatement.GetDocumentRange().IsValid())
            {
                var newStatement = psiServices.DoTransaction(ExpandCommandName, () =>
                {
                    // todo: pass original context?
                    var expression = csharpContext.Expression.GetOperandThroughParenthesis().NotNull();
                    return(CreateStatement(factory, expression));
                });

                var razorStatement = RazorUtil.FixExpressionToStatement(expressionRange, psiServices);
                if (razorStatement != null)
                {
                    return(psiServices.DoTransaction(ExpandCommandName, () =>
                    {
                        var statement = razorStatement.ReplaceBy(newStatement);

                        // force Razor's bracing style
                        var languageService = statement.Language.LanguageService().NotNull();
                        var formatter = languageService.CodeFormatter.NotNull();
                        formatter.Format(statement, CodeFormatProfile.SOFT, NullProgressIndicator.Instance);

                        return statement;
                    }));
                }

                Logger.Fail("Failed to resolve target statement to replace");
                return(null);
            }

            return(psiServices.DoTransaction(ExpandCommandName, () =>
            {
                var expression = csharpContext.Expression.GetOperandThroughParenthesis().NotNull();
                var newStatement = CreateStatement(factory, expression);

                Assertion.AssertNotNull(targetStatement, "targetStatement != null");
                Assertion.Assert(targetStatement.IsPhysical(), "targetStatement.IsPhysical()");

                // Sometimes statements produced by templates are unfinished (for example, because of
                // parentheses insertion mode in R#), so the created statements has error element at and,
                // prefixed with single-characted whitespace. We remove this whitespace here:
                var errorElement = newStatement.LastChild as IErrorElement;
                if (errorElement != null)
                {
                    var whitespaceNode = errorElement.PrevSibling as IWhitespaceNode;
                    if (whitespaceNode != null && !whitespaceNode.IsNewLine && whitespaceNode.GetText() == " ")
                    {
                        using (WriteLockCookie.Create(newStatement.IsPhysical()))
                        {
                            LowLevelModificationUtil.DeleteChild(whitespaceNode);
                        }
                    }
                }

                return targetStatement.ReplaceBy(newStatement);
            }));
        }