IG/IPP: remove duplication

2026-09-27 10:03:11 +07:00 · 2015-02-25 11:47:10 +01:00
parent 932ad9402b
commit 351eeb1373
5 changed files with 243 additions and 482 deletions
@@ -1,5 +1,5 @@
 /*
- * Copyright 2003-2013 Dave Griffith, Bas Leijdekkers
+ * Copyright 2003-2015 Dave Griffith, Bas Leijdekkers
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -18,26 +18,15 @@ package com.siyeh.ig;
 import com.intellij.codeInsight.FileModificationService;
 import com.intellij.codeInspection.LocalQuickFix;
 import com.intellij.codeInspection.ProblemDescriptor;
-import com.intellij.lang.Language;
-import com.intellij.lang.java.JavaLanguage;
 import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.TextRange;
-import com.intellij.psi.*;
-import com.intellij.psi.codeStyle.CodeStyleManager;
-import com.intellij.psi.codeStyle.JavaCodeStyleManager;
-import com.intellij.psi.util.PsiUtilCore;
+import com.intellij.psi.PsiElement;
 import com.intellij.util.IncorrectOperationException;
-import com.intellij.psi.util.FileTypeUtils;
-import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;

 public abstract class InspectionGadgetsFix implements LocalQuickFix {

  public static final InspectionGadgetsFix[] EMPTY_ARRAY = {};
-  private static final Logger LOG = Logger.getInstance("#com.siyeh.ig.InspectionGadgetsFix");

  private boolean myOnTheFly = false;

@@ -71,28 +60,6 @@ public abstract class InspectionGadgetsFix implements LocalQuickFix {
    element.delete();
  }

-  protected static String getElementText(@NotNull PsiElement element, @Nullable PsiElement elementToReplace, @Nullable String replacement) {
-    final StringBuilder out = new StringBuilder();
-    getElementText(element, elementToReplace, replacement, out);
-    return out.toString();
-  }
-
-  private static void getElementText(@NotNull PsiElement element, @Nullable PsiElement elementToReplace,
-                                     @Nullable String replacement, @NotNull StringBuilder out) {
-    if (element.equals(elementToReplace)) {
-      out.append(replacement);
-      return;
-    }
-    final PsiElement[] children = element.getChildren();
-    if (children.length == 0) {
-      out.append(element.getText());
-      return;
-    }
-    for (PsiElement child : children) {
-      getElementText(child, elementToReplace, replacement, out);
-    }
-  }
-
  public final void setOnTheFly(boolean onTheFly) {
    myOnTheFly = onTheFly;
  }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2014 JetBrains s.r.o.
+ * Copyright 2000-2015 JetBrains s.r.o.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -28,6 +28,7 @@ import com.intellij.psi.util.FileTypeUtils;
 import com.intellij.psi.util.PsiUtilCore;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;

 public class PsiReplacementUtil {
  private static final Logger LOG = Logger.getInstance("#" + PsiReplacementUtil.class.getName());
@@ -124,4 +125,27 @@ public class PsiReplacementUtil {
    final JavaCodeStyleManager styleManager = JavaCodeStyleManager.getInstance(project);
    styleManager.shortenClassReferences(element);
  }
+
+  @NotNull
+  public static String getElementText(@NotNull PsiElement element, @Nullable PsiElement elementToReplace, @Nullable String replacement) {
+    final StringBuilder out = new StringBuilder();
+    getElementText(element, elementToReplace, replacement, out);
+    return out.toString();
+  }
+
+  private static void getElementText(@NotNull PsiElement element, @Nullable PsiElement elementToReplace,
+                                     @Nullable String replacement, @NotNull StringBuilder out) {
+    if (element.equals(elementToReplace)) {
+      out.append(replacement);
+      return;
+    }
+    final PsiElement[] children = element.getChildren();
+    if (children.length == 0) {
+      out.append(element.getText());
+      return;
+    }
+    for (PsiElement child : children) {
+      getElementText(child, elementToReplace, replacement, out);
+    }
+  }
 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2003-2013 Dave Griffith, Bas Leijdekkers
+ * Copyright 2003-2015 Dave Griffith, Bas Leijdekkers
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -116,211 +116,216 @@ public class IncrementDecrementUsedAsExpressionInspection

    @Override
    protected void doFix(Project project, ProblemDescriptor descriptor) {
-      // see also the Extract Increment intention of IPP
-      final PsiElement element = descriptor.getPsiElement();
-      final PsiExpression operand;
+      extractPrefixPostfixExpressionToSeparateStatement(descriptor.getPsiElement());
+    }
+  }
+
+  public static void extractPrefixPostfixExpressionToSeparateStatement(PsiElement element) {
+    final PsiExpression operand;
+    if (element instanceof PsiPostfixExpression) {
+      final PsiPostfixExpression postfixExpression = (PsiPostfixExpression)element;
+      operand = postfixExpression.getOperand();
+    }
+    else if (element instanceof PsiPrefixExpression){
+      final PsiPrefixExpression prefixExpression = (PsiPrefixExpression)element;
+      operand = prefixExpression.getOperand();
+    }
+    else {
+      assert false;
+      return;
+    }
+    if (operand == null) {
+      return;
+    }
+    final PsiStatement statement =
+      PsiTreeUtil.getParentOfType(element, PsiStatement.class);
+    if (statement == null) {
+      return;
+    }
+    final PsiElement parent = statement.getParent();
+    if (parent == null) {
+      return;
+    }
+    final Project project = element.getProject();
+    final PsiElementFactory factory =
+      JavaPsiFacade.getInstance(project).getElementFactory();
+    final String newStatementText = element.getText() + ';';
+    final String operandText = operand.getText();
+    if (parent instanceof PsiIfStatement ||
+        parent instanceof PsiLoopStatement) {
+      // need to add braces because
+      // in/decrement is inside braceless control statement body
+      final StringBuilder text = new StringBuilder();
+      text.append('{');
+      final String elementText =
+        PsiReplacementUtil.getElementText(statement, element, operandText);
      if (element instanceof PsiPostfixExpression) {
-        final PsiPostfixExpression postfixExpression =
-          (PsiPostfixExpression)element;
-        operand = postfixExpression.getOperand();
+        text.append(elementText);
+        text.append(newStatementText);
      }
      else {
-        final PsiPrefixExpression prefixExpression =
-          (PsiPrefixExpression)element;
-        operand = prefixExpression.getOperand();
+        text.append(newStatementText);
+        text.append(elementText);
      }
-      if (operand == null) {
-        return;
-      }
-      final PsiStatement statement =
-        PsiTreeUtil.getParentOfType(element, PsiStatement.class);
-      if (statement == null) {
-        return;
-      }
-      final PsiElement parent = statement.getParent();
-      if (parent == null) {
-        return;
-      }
-      final PsiElementFactory factory =
-        JavaPsiFacade.getInstance(project).getElementFactory();
-      final String newStatementText = element.getText() + ';';
-      final String operandText = operand.getText();
-      if (parent instanceof PsiIfStatement ||
-          parent instanceof PsiLoopStatement) {
-        // need to add braces because
-        // in/decrement is inside braceless control statement body
-        final StringBuilder text = new StringBuilder();
-        text.append('{');
-        final String elementText =
-          getElementText(statement, element, operandText);
-        if (element instanceof PsiPostfixExpression) {
-          text.append(elementText);
-          text.append(newStatementText);
-        }
-        else {
-          text.append(newStatementText);
-          text.append(elementText);
-        }
-        text.append('}');
-        final PsiCodeBlock codeBlock =
-          factory.createCodeBlockFromText(text.toString(), parent);
-        statement.replace(codeBlock);
-        return;
-      }
-      final PsiStatement newStatement =
-        factory.createStatementFromText(newStatementText, element);
-      if (statement instanceof PsiReturnStatement) {
-        if (element instanceof PsiPostfixExpression) {
-          // special handling of postfix expression in return statement
-          final PsiReturnStatement returnStatement =
-            (PsiReturnStatement)statement;
-          final PsiExpression returnValue =
-            returnStatement.getReturnValue();
-          if (returnValue == null) {
-            return;
-          }
-          final JavaCodeStyleManager javaCodeStyleManager =
-            JavaCodeStyleManager.getInstance(project);
-          final String variableName =
-            javaCodeStyleManager.suggestUniqueVariableName(
-              "result", returnValue, true);
-          final PsiType type = returnValue.getType();
-          if (type == null) {
-            return;
-          }
-          final String newReturnValueText = getElementText(
-            returnValue, element, operandText);
-          final String declarationStatementText =
-            type.getCanonicalText() + ' ' + variableName +
-            '=' + newReturnValueText + ';';
-          final PsiStatement declarationStatement =
-            factory.createStatementFromText(declarationStatementText,
-                                            returnStatement);
-          parent.addBefore(declarationStatement, statement);
-          parent.addBefore(newStatement, statement);
-          final PsiStatement newReturnStatement =
-            factory.createStatementFromText(
-              "return " + variableName + ';',
-              returnStatement);
-          returnStatement.replace(newReturnStatement);
-          return;
-        }
-        else {
-          parent.addBefore(newStatement, statement);
-        }
-      }
-      else if (statement instanceof PsiThrowStatement) {
-        if (element instanceof PsiPostfixExpression) {
-          // special handling of postfix expression in throw statement
-          final PsiThrowStatement returnStatement =
-            (PsiThrowStatement)statement;
-          final PsiExpression exception =
-            returnStatement.getException();
-          if (exception == null) {
-            return;
-          }
-          final JavaCodeStyleManager javaCodeStyleManager =
-            JavaCodeStyleManager.getInstance(project);
-          final String variableName =
-            javaCodeStyleManager.suggestUniqueVariableName(
-              "e", exception, true);
-          final PsiType type = exception.getType();
-          if (type == null) {
-            return;
-          }
-          final String newReturnValueText = getElementText(
-            exception, element, operandText);
-          final String declarationStatementText =
-            type.getCanonicalText() + ' ' + variableName +
-            '=' + newReturnValueText + ';';
-          final PsiStatement declarationStatement =
-            factory.createStatementFromText(declarationStatementText,
-                                            returnStatement);
-          parent.addBefore(declarationStatement, statement);
-          parent.addBefore(newStatement, statement);
-          final PsiStatement newReturnStatement =
-            factory.createStatementFromText(
-              "throw " + variableName + ';',
-              returnStatement);
-          returnStatement.replace(newReturnStatement);
-          return;
-        }
-        else {
-          parent.addBefore(newStatement, statement);
-        }
-      }
-      else if (!(statement instanceof PsiForStatement)) {
-        if (element instanceof PsiPostfixExpression) {
-          parent.addAfter(newStatement, statement);
-        }
-        else {
-          parent.addBefore(newStatement, statement);
-        }
-      }
-      else if (operand instanceof PsiReferenceExpression) {
-        final PsiReferenceExpression referenceExpression =
-          (PsiReferenceExpression)operand;
-        final PsiElement target = referenceExpression.resolve();
-        if (target != null) {
-          final SearchScope useScope = target.getUseScope();
-          if (!new LocalSearchScope(statement).equals(useScope)) {
-            if (element instanceof PsiPostfixExpression) {
-              parent.addAfter(newStatement, statement);
-            }
-            else {
-              parent.addBefore(newStatement, statement);
-            }
-          }
-        }
-      }
-      if (statement instanceof PsiLoopStatement) {
-        // in/decrement inside loop statement condition
-        final PsiLoopStatement loopStatement =
-          (PsiLoopStatement)statement;
-        final PsiStatement body = loopStatement.getBody();
-        if (body instanceof PsiBlockStatement) {
-          final PsiBlockStatement blockStatement =
-            (PsiBlockStatement)body;
-          final PsiCodeBlock codeBlock =
-            blockStatement.getCodeBlock();
-          if (element instanceof PsiPostfixExpression) {
-            final PsiElement firstElement =
-              codeBlock.getFirstBodyElement();
-            codeBlock.addBefore(newStatement, firstElement);
-          }
-          else {
-            codeBlock.add(newStatement);
-          }
-        }
-        else {
-          final StringBuilder blockText = new StringBuilder();
-          blockText.append('{');
-          if (element instanceof PsiPostfixExpression) {
-            blockText.append(newStatementText);
-            if (body != null) {
-              blockText.append(body.getText());
-            }
-          }
-          else {
-            if (body != null) {
-              blockText.append(body.getText());
-            }
-            blockText.append(newStatementText);
-          }
-          blockText.append('}');
-          final PsiStatement blockStatement =
-            factory.createStatementFromText(
-              blockText.toString(), statement);
-          if (body == null) {
-            loopStatement.add(blockStatement);
-          }
-          else {
-            body.replace(blockStatement);
-          }
-        }
-      }
-      PsiReplacementUtil.replaceExpression((PsiExpression)element, operandText);
+      text.append('}');
+      final PsiCodeBlock codeBlock =
+        factory.createCodeBlockFromText(text.toString(), parent);
+      statement.replace(codeBlock);
+      return;
    }
+    final PsiStatement newStatement =
+      factory.createStatementFromText(newStatementText, element);
+    if (statement instanceof PsiReturnStatement) {
+      if (element instanceof PsiPostfixExpression) {
+        // special handling of postfix expression in return statement
+        final PsiReturnStatement returnStatement =
+          (PsiReturnStatement)statement;
+        final PsiExpression returnValue =
+          returnStatement.getReturnValue();
+        if (returnValue == null) {
+          return;
+        }
+        final JavaCodeStyleManager javaCodeStyleManager =
+          JavaCodeStyleManager.getInstance(project);
+        final String variableName =
+          javaCodeStyleManager.suggestUniqueVariableName(
+            "result", returnValue, true);
+        final PsiType type = returnValue.getType();
+        if (type == null) {
+          return;
+        }
+        final String newReturnValueText = PsiReplacementUtil.getElementText(
+          returnValue, element, operandText);
+        final String declarationStatementText =
+          type.getCanonicalText() + ' ' + variableName +
+          '=' + newReturnValueText + ';';
+        final PsiStatement declarationStatement =
+          factory.createStatementFromText(declarationStatementText,
+                                          returnStatement);
+        parent.addBefore(declarationStatement, statement);
+        parent.addBefore(newStatement, statement);
+        final PsiStatement newReturnStatement =
+          factory.createStatementFromText(
+            "return " + variableName + ';',
+            returnStatement);
+        returnStatement.replace(newReturnStatement);
+        return;
+      }
+      else {
+        parent.addBefore(newStatement, statement);
+      }
+    }
+    else if (statement instanceof PsiThrowStatement) {
+      if (element instanceof PsiPostfixExpression) {
+        // special handling of postfix expression in throw statement
+        final PsiThrowStatement returnStatement =
+          (PsiThrowStatement)statement;
+        final PsiExpression exception =
+          returnStatement.getException();
+        if (exception == null) {
+          return;
+        }
+        final JavaCodeStyleManager javaCodeStyleManager =
+          JavaCodeStyleManager.getInstance(project);
+        final String variableName =
+          javaCodeStyleManager.suggestUniqueVariableName(
+            "e", exception, true);
+        final PsiType type = exception.getType();
+        if (type == null) {
+          return;
+        }
+        final String newReturnValueText = PsiReplacementUtil.getElementText(
+          exception, element, operandText);
+        final String declarationStatementText =
+          type.getCanonicalText() + ' ' + variableName +
+          '=' + newReturnValueText + ';';
+        final PsiStatement declarationStatement =
+          factory.createStatementFromText(declarationStatementText,
+                                          returnStatement);
+        parent.addBefore(declarationStatement, statement);
+        parent.addBefore(newStatement, statement);
+        final PsiStatement newReturnStatement =
+          factory.createStatementFromText(
+            "throw " + variableName + ';',
+            returnStatement);
+        returnStatement.replace(newReturnStatement);
+        return;
+      }
+      else {
+        parent.addBefore(newStatement, statement);
+      }
+    }
+    else if (!(statement instanceof PsiForStatement)) {
+      if (element instanceof PsiPostfixExpression) {
+        parent.addAfter(newStatement, statement);
+      }
+      else {
+        parent.addBefore(newStatement, statement);
+      }
+    }
+    else if (operand instanceof PsiReferenceExpression) {
+      final PsiReferenceExpression referenceExpression =
+        (PsiReferenceExpression)operand;
+      final PsiElement target = referenceExpression.resolve();
+      if (target != null) {
+        final SearchScope useScope = target.getUseScope();
+        if (!new LocalSearchScope(statement).equals(useScope)) {
+          if (element instanceof PsiPostfixExpression) {
+            parent.addAfter(newStatement, statement);
+          }
+          else {
+            parent.addBefore(newStatement, statement);
+          }
+        }
+      }
+    }
+    if (statement instanceof PsiLoopStatement) {
+      // in/decrement inside loop statement condition
+      final PsiLoopStatement loopStatement =
+        (PsiLoopStatement)statement;
+      final PsiStatement body = loopStatement.getBody();
+      if (body instanceof PsiBlockStatement) {
+        final PsiBlockStatement blockStatement =
+          (PsiBlockStatement)body;
+        final PsiCodeBlock codeBlock =
+          blockStatement.getCodeBlock();
+        if (element instanceof PsiPostfixExpression) {
+          final PsiElement firstElement =
+            codeBlock.getFirstBodyElement();
+          codeBlock.addBefore(newStatement, firstElement);
+        }
+        else {
+          codeBlock.add(newStatement);
+        }
+      }
+      else {
+        final StringBuilder blockText = new StringBuilder();
+        blockText.append('{');
+        if (element instanceof PsiPostfixExpression) {
+          blockText.append(newStatementText);
+          if (body != null) {
+            blockText.append(body.getText());
+          }
+        }
+        else {
+          if (body != null) {
+            blockText.append(body.getText());
+          }
+          blockText.append(newStatementText);
+        }
+        blockText.append('}');
+        final PsiStatement blockStatement =
+          factory.createStatementFromText(
+            blockText.toString(), statement);
+        if (body == null) {
+          loopStatement.add(blockStatement);
+        }
+        else {
+          body.replace(blockStatement);
+        }
+      }
+    }
+    PsiReplacementUtil.replaceExpression((PsiExpression)element, operandText);
  }

  @Override
@@ -1,5 +1,5 @@
 /*
- * Copyright 2007-2012 Bas Leijdekkers
+ * Copyright 2007-2015 Bas Leijdekkers
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -80,10 +80,7 @@ public class ToArrayCallWithZeroLengthArrayArgumentInspection extends ToArrayCal
      final String typeText = componentType.getCanonicalText();
      if (!(qualifier instanceof PsiMethodCallExpression)) {
        @NonNls final String replacementText = "new " + typeText + '[' + collectionText + ".size()]";
-        final String newExpressionText = getElementText(methodCallExpression, argument, replacementText);
-        if (newExpressionText == null) {
-          return;
-        }
+        final String newExpressionText = PsiReplacementUtil.getElementText(methodCallExpression, argument, replacementText);
        PsiReplacementUtil.replaceExpression(methodCallExpression, newExpressionText);
        return;
      }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2003-2008 Dave Griffith, Bas Leijdekkers
+ * Copyright 2003-2015 Dave Griffith, Bas Leijdekkers
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -15,19 +15,15 @@
 */
 package com.siyeh.ipp.increment;

-import com.intellij.openapi.project.Project;
-import com.intellij.psi.*;
-import com.intellij.psi.codeStyle.JavaCodeStyleManager;
-import com.intellij.psi.search.LocalSearchScope;
-import com.intellij.psi.search.SearchScope;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.util.IncorrectOperationException;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiJavaToken;
+import com.intellij.psi.PsiPostfixExpression;
+import com.intellij.psi.PsiPrefixExpression;
 import com.siyeh.IntentionPowerPackBundle;
-import com.siyeh.ig.PsiReplacementUtil;
+import com.siyeh.ig.assignment.IncrementDecrementUsedAsExpressionInspection;
 import com.siyeh.ipp.base.MutablyNamedIntention;
 import com.siyeh.ipp.base.PsiElementPredicate;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;

 public class ExtractIncrementIntention extends MutablyNamedIntention {

@@ -52,235 +48,7 @@ public class ExtractIncrementIntention extends MutablyNamedIntention {
  }

  @Override
-  public void processIntention(@NotNull PsiElement element)
-    throws IncorrectOperationException {
-    final PsiExpression operand;
-    if (element instanceof PsiPostfixExpression) {
-      final PsiPostfixExpression postfixExpression =
-        (PsiPostfixExpression)element;
-      operand = postfixExpression.getOperand();
-    }
-    else {
-      final PsiPrefixExpression prefixExpression =
-        (PsiPrefixExpression)element;
-      operand = prefixExpression.getOperand();
-    }
-    if (operand == null) {
-      return;
-    }
-    final PsiStatement statement =
-      PsiTreeUtil.getParentOfType(element, PsiStatement.class);
-    if (statement == null) {
-      return;
-    }
-    final PsiElement parent = statement.getParent();
-    if (parent == null) {
-      return;
-    }
-    final Project project = element.getProject();
-    final PsiElementFactory factory =
-      JavaPsiFacade.getInstance(project).getElementFactory();
-    final String newStatementText = element.getText() + ';';
-    final String operandText = operand.getText();
-    if (parent instanceof PsiIfStatement ||
-        parent instanceof PsiLoopStatement) {
-      // need to add braces because
-      // in/decrement is inside braceless control statement body
-      final StringBuilder text = new StringBuilder();
-      text.append('{');
-      final String elementText =
-        getElementText(statement, element, operandText);
-      if (element instanceof PsiPostfixExpression) {
-        text.append(elementText);
-        text.append(newStatementText);
-      }
-      else {
-        text.append(newStatementText);
-        text.append(elementText);
-      }
-      text.append('}');
-      final PsiCodeBlock codeBlock =
-        factory.createCodeBlockFromText(text.toString(), parent);
-      statement.replace(codeBlock);
-      return;
-    }
-    final PsiStatement newStatement =
-      factory.createStatementFromText(newStatementText, element);
-    if (statement instanceof PsiReturnStatement) {
-      if (element instanceof PsiPostfixExpression) {
-        // special handling of postfix expression in return statement
-        final PsiReturnStatement returnStatement =
-          (PsiReturnStatement)statement;
-        final PsiExpression returnValue =
-          returnStatement.getReturnValue();
-        if (returnValue == null) {
-          return;
-        }
-        final JavaCodeStyleManager javaCodeStyleManager =
-          JavaCodeStyleManager.getInstance(project);
-        final String variableName =
-          javaCodeStyleManager.suggestUniqueVariableName(
-            "result", returnValue, true);
-        final PsiType type = returnValue.getType();
-        if (type == null) {
-          return;
-        }
-        final String newReturnValueText = getElementText(
-          returnValue, element, operandText);
-        final String declarationStatementText =
-          type.getCanonicalText() + ' ' + variableName +
-          '=' + newReturnValueText + ';';
-        final PsiStatement declarationStatement =
-          factory.createStatementFromText(declarationStatementText,
-                                          returnStatement);
-        parent.addBefore(declarationStatement, statement);
-        parent.addBefore(newStatement, statement);
-        final PsiStatement newReturnStatement =
-          factory.createStatementFromText(
-            "return " + variableName + ';',
-            returnStatement);
-        returnStatement.replace(newReturnStatement);
-        return;
-      }
-      else {
-        parent.addBefore(newStatement, statement);
-      }
-    }
-    else if (statement instanceof PsiThrowStatement) {
-      if (element instanceof PsiPostfixExpression) {
-        // special handling of postfix expression in throw statement
-        final PsiThrowStatement returnStatement =
-          (PsiThrowStatement)statement;
-        final PsiExpression exception =
-          returnStatement.getException();
-        if (exception == null) {
-          return;
-        }
-        final JavaCodeStyleManager javaCodeStyleManager =
-          JavaCodeStyleManager.getInstance(project);
-        final String variableName =
-          javaCodeStyleManager.suggestUniqueVariableName(
-            "e", exception, true);
-        final PsiType type = exception.getType();
-        if (type == null) {
-          return;
-        }
-        final String newReturnValueText = getElementText(
-          exception, element, operandText);
-        final String declarationStatementText =
-          type.getCanonicalText() + ' ' + variableName +
-          '=' + newReturnValueText + ';';
-        final PsiStatement declarationStatement =
-          factory.createStatementFromText(declarationStatementText,
-                                          returnStatement);
-        parent.addBefore(declarationStatement, statement);
-        parent.addBefore(newStatement, statement);
-        final PsiStatement newReturnStatement =
-          factory.createStatementFromText(
-            "throw " + variableName + ';',
-            returnStatement);
-        returnStatement.replace(newReturnStatement);
-        return;
-      }
-      else {
-        parent.addBefore(newStatement, statement);
-      }
-    }
-    else if (!(statement instanceof PsiForStatement)) {
-      if (element instanceof PsiPostfixExpression) {
-        parent.addAfter(newStatement, statement);
-      }
-      else {
-        parent.addBefore(newStatement, statement);
-      }
-    }
-    else if (operand instanceof PsiReferenceExpression) {
-      final PsiReferenceExpression referenceExpression =
-        (PsiReferenceExpression)operand;
-      final PsiElement target = referenceExpression.resolve();
-      if (target != null) {
-        final SearchScope useScope = target.getUseScope();
-        if (!new LocalSearchScope(statement).equals(useScope)) {
-          if (element instanceof PsiPostfixExpression) {
-            parent.addAfter(newStatement, statement);
-          }
-          else {
-            parent.addBefore(newStatement, statement);
-          }
-        }
-      }
-    }
-    if (statement instanceof PsiLoopStatement) {
-      // in/decrement inside loop statement condition
-      final PsiLoopStatement loopStatement = (PsiLoopStatement)statement;
-      final PsiStatement body = loopStatement.getBody();
-      if (body instanceof PsiBlockStatement) {
-        final PsiBlockStatement blockStatement =
-          (PsiBlockStatement)body;
-        final PsiCodeBlock codeBlock = blockStatement.getCodeBlock();
-        if (element instanceof PsiPostfixExpression) {
-          final PsiElement firstElement =
-            codeBlock.getFirstBodyElement();
-          codeBlock.addBefore(newStatement, firstElement);
-        }
-        else {
-          codeBlock.add(newStatement);
-        }
-      }
-      else {
-        final StringBuilder blockText = new StringBuilder();
-        blockText.append('{');
-        if (element instanceof PsiPostfixExpression) {
-          blockText.append(newStatementText);
-          if (body != null) {
-            blockText.append(body.getText());
-          }
-        }
-        else {
-          if (body != null) {
-            blockText.append(body.getText());
-          }
-          blockText.append(newStatementText);
-        }
-        blockText.append('}');
-        final PsiStatement blockStatement =
-          factory.createStatementFromText(blockText.toString(),
-                                          statement);
-        if (body == null) {
-          loopStatement.add(blockStatement);
-        }
-        else {
-          body.replace(blockStatement);
-        }
-      }
-    }
-    PsiReplacementUtil.replaceExpression((PsiExpression)element, operandText);
-  }
-
-  private static String getElementText(@NotNull PsiElement element,
-                                       @Nullable PsiElement elementToReplace,
-                                       @Nullable String replacement) {
-    final StringBuilder out = new StringBuilder();
-    getElementText(element, elementToReplace, replacement, out);
-    return out.toString();
-  }
-
-  private static void getElementText(
-    @NotNull PsiElement element,
-    @Nullable PsiElement elementToReplace,
-    @Nullable String replacement,
-    @NotNull StringBuilder out) {
-    if (element.equals(elementToReplace)) {
-      out.append(replacement);
-      return;
-    }
-    final PsiElement[] children = element.getChildren();
-    if (children.length == 0) {
-      out.append(element.getText());
-      return;
-    }
-    for (PsiElement child : children) {
-      getElementText(child, elementToReplace, replacement, out);
-    }
+  public void processIntention(@NotNull PsiElement element) {
+    IncrementDecrementUsedAsExpressionInspection.extractPrefixPostfixExpressionToSeparateStatement(element);
  }
 }