refactoring/impl/com/intellij/refactoring/rename/JavaNameSuggestionProvider.java

   1 package com.intellij.refactoring.rename;
   2
   3 import com.intellij.codeInsight.completion.JavaCompletionUtil;
   4 import com.intellij.codeInsight.lookup.LookupItem;
   5 import com.intellij.codeInsight.lookup.LookupItemUtil;
   6 import com.intellij.codeInsight.lookup.LookupElement;
   7 import com.intellij.openapi.util.text.StringUtil;
   8 import com.intellij.psi.*;
   9 import com.intellij.psi.util.PropertyUtil;
  10 import com.intellij.psi.codeStyle.JavaCodeStyleManager;
  11 import com.intellij.psi.codeStyle.NameUtil;
  12 import com.intellij.psi.codeStyle.SuggestedNameInfo;
  13 import com.intellij.psi.codeStyle.VariableKind;
  14 import com.intellij.usageView.UsageViewUtil;
  15 import com.intellij.util.ArrayUtil;
  16 import com.intellij.util.containers.ContainerUtil;
  17 import org.jetbrains.annotations.Nullable;
  18
  19 import java.util.*;
  20
  21 public class JavaNameSuggestionProvider implements NameSuggestionProvider {
  22   @Nullable
  23   public SuggestedNameInfo getSuggestedNames(final PsiElement element, final PsiElement nameSuggestionContext, List<String> result) {
  24     String initialName = UsageViewUtil.getShortName(element);
  25     SuggestedNameInfo info = suggestNamesForElement(element);
  26
  27     String parameterName = null;
  28     String superMethodName = null;
  29     if (nameSuggestionContext != null) {
  30       final PsiElement nameSuggestionContextParent = nameSuggestionContext.getParent();
  31       if (nameSuggestionContextParent != null) {
  32         final PsiElement parentOfParent = nameSuggestionContextParent.getParent();
  33         if (parentOfParent instanceof PsiExpressionList) {
  34           final PsiExpressionList expressionList = (PsiExpressionList)parentOfParent;
  35           final PsiElement parent = expressionList.getParent();
  36           if (parent instanceof PsiCallExpression) {
  37             final PsiMethod method = ((PsiCallExpression)parent).resolveMethod();
  38             if (method != null) {
  39               final PsiParameter[] parameters = method.getParameterList().getParameters();
  40               final PsiExpression[] expressions = expressionList.getExpressions();
  41               for (int i = 0; i < expressions.length; i++) {
  42                 PsiExpression expression = expressions[i];
  43                 if (expression == nameSuggestionContextParent) {
  44                   if (i < parameters.length) {
  45                     parameterName = parameters[i].getName();
  46                   }
  47                   break;
  48                 }
  49               }
  50             }
  51           }
  52         }
  53         else if (parentOfParent instanceof PsiParameterList) {
  54           final PsiElement parent3 = parentOfParent.getParent();
  55           if (parent3 instanceof PsiMethod) {
  56             final String propName = PropertyUtil.getPropertyName((PsiMethod)parent3);
  57             if (propName != null) {
  58               parameterName = propName;
  59             }
  60             if (nameSuggestionContextParent instanceof PsiParameter) {
  61               superMethodName = getSuperMethodName((PsiParameter) nameSuggestionContextParent, (PsiMethod) parent3);
  62             }
  63           }
  64         }
  65       }
  66     }
  67     final String[] strings = info != null ? info.names : ArrayUtil.EMPTY_STRING_ARRAY;
  68     ArrayList<String> list = new ArrayList<String>(Arrays.asList(strings));
  69     final String properlyCased = suggestProperlyCasedName(element);
  70     if (!list.contains(initialName)) {
  71       list.add(0, initialName);
  72     }
  73     else {
  74       int i = list.indexOf(initialName);
  75       list.remove(i);
  76       list.add(0, initialName);
  77     }
  78     if (properlyCased != null && !properlyCased.equals(initialName)) {
  79       list.add(1, properlyCased);
  80     }
  81     if (parameterName != null && !list.contains(parameterName)) {
  82       list.add(parameterName);
  83     }
  84     if (superMethodName != null && !list.contains(superMethodName)) {
  85       list.add(0, superMethodName);
  86     }
  87     ContainerUtil.removeDuplicates(list);
  88     result.addAll(list);
  89     return info;
  90   }
  91
  92   @Nullable
  93   private static String getSuperMethodName(final PsiParameter psiParameter, final PsiMethod method) {
  94     final int index = method.getParameterList().getParameterIndex(psiParameter);
  95     final PsiMethod[] superMethods = method.findSuperMethods();
  96     for (PsiMethod superMethod : superMethods) {
  97       final PsiParameterList superParameters = superMethod.getParameterList();
  98       if (index < superParameters.getParametersCount()) {
  99         return superParameters.getParameters() [index].getName();
 100       }
 101     }
 102     return null;
 103   }
 104
 105   @Nullable
 106   public Collection<LookupElement> completeName(final PsiElement element, final PsiElement nameSuggestionContext, final String prefix) {
 107     if (element instanceof PsiVariable) {
 108       PsiVariable var = (PsiVariable)element;
 109       VariableKind kind = JavaCodeStyleManager.getInstance(element.getProject()).getVariableKind(var);
 110       Set<LookupItem> set = new LinkedHashSet<LookupItem>();
 111       JavaCompletionUtil.completeVariableNameForRefactoring(element.getProject(), set, prefix, var.getType(), kind);
 112
 113       if (prefix.length() == 0) {
 114         List<String> suggestedNames = new ArrayList<String>();
 115         getSuggestedNames(element, nameSuggestionContext, suggestedNames);
 116         for (String suggestedName : suggestedNames) {
 117           LookupItemUtil.addLookupItem(set, suggestedName);
 118         }
 119       }
 120
 121     }
 122     return null;
 123   }
 124
 125   @Nullable
 126   private static String suggestProperlyCasedName(PsiElement psiElement) {
 127     if (!(psiElement instanceof PsiNamedElement)) return null;
 128     String name = ((PsiNamedElement)psiElement).getName();
 129     if (name == null) return null;
 130     if (psiElement instanceof PsiVariable) {
 131       final JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(psiElement.getProject());
 132       final VariableKind kind = codeStyleManager.getVariableKind((PsiVariable)psiElement);
 133       final String prefix = codeStyleManager.getPrefixByVariableKind(kind);
 134       if (name.startsWith(prefix)) {
 135         name = name.substring(prefix.length());
 136       }
 137       final String[] words = NameUtil.splitNameIntoWords(name);
 138       if (kind == VariableKind.STATIC_FINAL_FIELD) {
 139         StringBuilder buffer = new StringBuilder();
 140         for (int i = 0; i < words.length; i++) {
 141           String word = words[i];
 142           if (i > 0) buffer.append('_');
 143           buffer.append(word.toUpperCase());
 144         }
 145         return buffer.toString();
 146       }
 147       else {
 148         StringBuilder buffer = new StringBuilder(prefix);
 149         for (int i = 0; i < words.length; i++) {
 150           String word = words[i];
 151           final boolean prefixRequiresCapitalization = prefix.length() > 0 && !StringUtil.endsWithChar(prefix, '_');
 152           if (i > 0 || prefixRequiresCapitalization) {
 153             buffer.append(StringUtil.capitalize(word));
 154           }
 155           else {
 156             buffer.append(StringUtil.decapitalize(word));
 157           }
 158         }
 159         return buffer.toString();
 160       }
 161
 162     }
 163     return name;
 164   }
 165
 166   @Nullable
 167   private static SuggestedNameInfo suggestNamesForElement(final PsiElement element) {
 168     PsiVariable var = null;
 169     if (element instanceof PsiVariable) {
 170       var = (PsiVariable)element;
 171     }
 172     else if (element instanceof PsiIdentifier) {
 173       PsiIdentifier identifier = (PsiIdentifier)element;
 174       if (identifier.getParent() instanceof PsiVariable) {
 175         var = (PsiVariable)identifier.getParent();
 176       }
 177     }
 178
 179     if (var == null) return null;
 180
 181     JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(element.getProject());
 182     VariableKind variableKind = codeStyleManager.getVariableKind(var);
 183     return codeStyleManager.suggestVariableName(variableKind, null, var.getInitializer(), var.getType());
 184   }
 185
 186 }