java/java-impl/src/com/intellij/refactoring/makeStatic/MakeMethodStaticProcessor.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.refactoring.makeStatic;
  17
  18 import com.intellij.openapi.diagnostic.Logger;
  19 import com.intellij.openapi.project.Project;
  20 import com.intellij.psi.*;
  21 import com.intellij.psi.codeStyle.CodeStyleManager;
  22 import com.intellij.psi.javadoc.PsiDocTag;
  23 import com.intellij.psi.util.InheritanceUtil;
  24 import com.intellij.psi.util.PsiTreeUtil;
  25 import com.intellij.psi.util.PsiUtil;
  26 import com.intellij.refactoring.util.RefactoringUtil;
  27 import com.intellij.refactoring.util.javadoc.MethodJavaDocHelper;
  28 import com.intellij.usageView.UsageInfo;
  29 import com.intellij.util.IncorrectOperationException;
  30
  31 import java.util.ArrayList;
  32 import java.util.List;
  33
  34 /**
  35  * @author dsl
  36  */
  37 public class MakeMethodStaticProcessor extends MakeMethodOrClassStaticProcessor<PsiMethod> {
  38   private static final Logger LOG = Logger.getInstance("#com.intellij.refactoring.makeMethodStatic.MakeMethodStaticProcessor");
  39
  40   public MakeMethodStaticProcessor(final Project project, final PsiMethod method, final Settings settings) {
  41     super(project, method, settings);
  42   }
  43
  44   protected void changeSelfUsage(SelfUsageInfo usageInfo) throws IncorrectOperationException {
  45     PsiElement parent = usageInfo.getElement().getParent();
  46     LOG.assertTrue(parent instanceof PsiMethodCallExpression);
  47     PsiMethodCallExpression methodCall = (PsiMethodCallExpression) parent;
  48     final PsiExpression qualifier = methodCall.getMethodExpression().getQualifierExpression();
  49     if (qualifier != null) qualifier.delete();
  50
  51     PsiElementFactory factory = JavaPsiFacade.getInstance(methodCall.getProject()).getElementFactory();
  52     PsiExpressionList args = methodCall.getArgumentList();
  53     PsiElement addParameterAfter = null;
  54
  55     if(mySettings.isMakeClassParameter()) {
  56       PsiElement arg = factory.createExpressionFromText(mySettings.getClassParameterName(), null);
  57       addParameterAfter = args.addAfter(arg, null);
  58     }
  59
  60     if(mySettings.isMakeFieldParameters()) {
  61       List<Settings.FieldParameter> parameters = mySettings.getParameterOrderList();
  62       for (Settings.FieldParameter fieldParameter : parameters) {
  63         PsiElement arg = factory.createExpressionFromText(fieldParameter.name, null);
  64         if (addParameterAfter == null) {
  65           addParameterAfter = args.addAfter(arg, null);
  66         }
  67         else {
  68           addParameterAfter = args.addAfter(arg, addParameterAfter);
  69         }
  70       }
  71     }
  72   }
  73
  74   protected void changeSelf(PsiElementFactory factory, UsageInfo[] usages)
  75           throws IncorrectOperationException {
  76     final MethodJavaDocHelper javaDocHelper = new MethodJavaDocHelper(myMember);
  77     PsiParameterList paramList = myMember.getParameterList();
  78     PsiElement addParameterAfter = null;
  79     PsiDocTag anchor = null;
  80     List<PsiType> addedTypes = new ArrayList<PsiType>();
  81
  82     if (mySettings.isMakeClassParameter()) {
  83       // Add parameter for object
  84       PsiType parameterType = factory.createType(myMember.getContainingClass(), PsiSubstitutor.EMPTY);
  85       addedTypes.add(parameterType);
  86
  87       final String classParameterName = mySettings.getClassParameterName();
  88       PsiParameter parameter = factory.createParameter(classParameterName, parameterType);
  89       if(makeClassParameterFinal(usages)) {
  90         PsiUtil.setModifierProperty(parameter, PsiModifier.FINAL, true);
  91       }
  92       addParameterAfter = paramList.addAfter(parameter, null);
  93       anchor = javaDocHelper.addParameterAfter(classParameterName, anchor);
  94     }
  95
  96     if (mySettings.isMakeFieldParameters()) {
  97       List<Settings.FieldParameter> parameters = mySettings.getParameterOrderList();
  98
  99       for (Settings.FieldParameter fieldParameter : parameters) {
 100         final PsiType fieldParameterType = fieldParameter.field.getType();
 101         final PsiParameter parameter = factory.createParameter(fieldParameter.name, fieldParameterType);
 102         addedTypes.add(fieldParameterType);
 103         if (makeFieldParameterFinal(fieldParameter.field, usages)) {
 104           PsiUtil.setModifierProperty(parameter, PsiModifier.FINAL, true);
 105         }
 106         addParameterAfter = paramList.addAfter(parameter, addParameterAfter);
 107         anchor = javaDocHelper.addParameterAfter(fieldParameter.name, anchor);
 108       }
 109     }
 110     setupTypeParameterList();
 111     // Add static modifier
 112     final PsiModifierList modifierList = myMember.getModifierList();
 113     modifierList.setModifierProperty(PsiModifier.STATIC, true);
 114     modifierList.setModifierProperty(PsiModifier.FINAL, false);
 115   }
 116
 117   protected void changeInternalUsage(InternalUsageInfo usage, PsiElementFactory factory)
 118           throws IncorrectOperationException {
 119     if (!mySettings.isChangeSignature()) return;
 120
 121     PsiElement element = usage.getElement();
 122
 123     if (element instanceof PsiReferenceExpression) {
 124       PsiReferenceExpression newRef = null;
 125
 126       if (mySettings.isMakeFieldParameters()) {
 127         PsiElement resolved = ((PsiReferenceExpression) element).resolve();
 128         if (resolved instanceof PsiField) {
 129           String name = mySettings.getNameForField((PsiField) resolved);
 130           if (name != null) {
 131             newRef = (PsiReferenceExpression) factory.createExpressionFromText(name, null);
 132           }
 133         }
 134       }
 135
 136       if (newRef == null && mySettings.isMakeClassParameter()) {
 137         newRef =
 138         (PsiReferenceExpression) factory.createExpressionFromText(
 139                 mySettings.getClassParameterName() + "." + element.getText(), null);
 140       }
 141
 142       if (newRef != null) {
 143         CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(myProject);
 144         newRef = (PsiReferenceExpression) codeStyleManager.reformat(newRef);
 145         element.replace(newRef);
 146       }
 147     }
 148     else if (element instanceof PsiThisExpression && mySettings.isMakeClassParameter()) {
 149       element.replace(factory.createExpressionFromText(mySettings.getClassParameterName(), null));
 150     }
 151     else if (element instanceof PsiSuperExpression && mySettings.isMakeClassParameter()) {
 152       element.replace(factory.createExpressionFromText(mySettings.getClassParameterName(), null));
 153     }
 154     else if (element instanceof PsiNewExpression && mySettings.isMakeClassParameter()) {
 155       final PsiNewExpression newExpression = ((PsiNewExpression)element);
 156       LOG.assertTrue(newExpression.getQualifier() == null);
 157       final String newText = mySettings.getClassParameterName() + "." + newExpression.getText();
 158       final PsiExpression expr = factory.createExpressionFromText(newText, null);
 159       element.replace(expr);
 160     }
 161   }
 162
 163   protected void changeExternalUsage(UsageInfo usage, PsiElementFactory factory)
 164           throws IncorrectOperationException {
 165     final PsiElement element = usage.getElement();
 166     if (!(element instanceof PsiReferenceExpression)) return;
 167
 168     PsiReferenceExpression methodRef = (PsiReferenceExpression) element;
 169     PsiElement parent = methodRef.getParent();
 170     LOG.assertTrue(parent instanceof PsiMethodCallExpression);
 171
 172     PsiMethodCallExpression methodCall = (PsiMethodCallExpression) parent;
 173     PsiExpression instanceRef;
 174
 175     instanceRef = methodRef.getQualifierExpression();
 176     PsiElement newQualifier;
 177
 178     final PsiClass memberClass = myMember.getContainingClass();
 179     if (instanceRef == null || instanceRef instanceof PsiSuperExpression) {
 180       PsiClass contextClass = PsiTreeUtil.getParentOfType(element, PsiClass.class);
 181       if (!InheritanceUtil.isInheritorOrSelf(contextClass, memberClass, true)) {
 182         instanceRef = factory.createExpressionFromText(memberClass.getQualifiedName() + ".this", null);
 183       } else {
 184         instanceRef = factory.createExpressionFromText("this", null);
 185       }
 186       newQualifier = null;
 187     }
 188     else {
 189       newQualifier = factory.createReferenceExpression(memberClass);
 190     }
 191
 192     if (mySettings.getNewParametersNumber() > 1) {
 193       int copyingSafetyLevel = RefactoringUtil.verifySafeCopyExpression(instanceRef);
 194       if (copyingSafetyLevel == RefactoringUtil.EXPR_COPY_PROHIBITED) {
 195         String tempVar = RefactoringUtil.createTempVar(instanceRef, methodCall, true);
 196         instanceRef = factory.createExpressionFromText(tempVar, null);
 197       }
 198     }
 199
 200
 201     PsiElement anchor = null;
 202     PsiExpressionList argList = methodCall.getArgumentList();
 203     PsiExpression[] exprs = argList.getExpressions();
 204     if (mySettings.isMakeClassParameter()) {
 205       if (exprs.length > 0) {
 206         anchor = argList.addBefore(instanceRef, exprs[0]);
 207       }
 208       else {
 209         anchor = argList.add(instanceRef);
 210       }
 211     }
 212
 213
 214     if (mySettings.isMakeFieldParameters()) {
 215       List<Settings.FieldParameter> parameters = mySettings.getParameterOrderList();
 216
 217       for (Settings.FieldParameter fieldParameter : parameters) {
 218         PsiReferenceExpression fieldRef;
 219         if (newQualifier != null) {
 220           fieldRef = (PsiReferenceExpression)factory.createExpressionFromText(
 221             "a." + fieldParameter.field.getName(), null);
 222           fieldRef.getQualifierExpression().replace(instanceRef);
 223         }
 224         else {
 225           fieldRef = (PsiReferenceExpression)factory.createExpressionFromText(fieldParameter.field.getName(), null);
 226         }
 227
 228         if (anchor != null) {
 229           anchor = argList.addAfter(fieldRef, anchor);
 230         }
 231         else {
 232           if (exprs.length > 0) {
 233             anchor = argList.addBefore(fieldRef, exprs[0]);
 234           }
 235           else {
 236             anchor = argList.add(fieldRef);
 237           }
 238         }
 239       }
 240     }
 241
 242     if (newQualifier != null) {
 243       methodRef.getQualifierExpression().replace(newQualifier);
 244     }
 245   }
 246
 247   protected void findExternalUsages(final ArrayList<UsageInfo> result) {
 248     findExternalReferences(myMember, result);
 249   }
 250 }