java/java-impl/src/com/intellij/refactoring/replaceConstructorWithBuilder/ParameterData.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
  17 /*
  18  * User: anna
  19  * Date: 04-Feb-2009
  20  */
  21 package com.intellij.refactoring.replaceConstructorWithBuilder;
  22
  23 import com.intellij.openapi.diagnostic.Logger;
  24 import com.intellij.psi.*;
  25 import com.intellij.psi.codeStyle.JavaCodeStyleManager;
  26 import com.intellij.psi.codeStyle.VariableKind;
  27 import com.intellij.psi.util.PropertyUtil;
  28 import org.jetbrains.annotations.Nullable;
  29
  30 import java.util.Map;
  31
  32 public class ParameterData {
  33   private final String myName;
  34   private final String myParameterName;
  35   private final PsiType myType;
  36   private String myFieldName;
  37   private String mySetterName;
  38   private String myDefaultValue;
  39   private boolean myInsertSetter = true;
  40   private static final Logger LOG = Logger.getInstance("#" + ParameterData.class.getName());
  41
  42   public ParameterData(String name, String parameterName, PsiType type) {
  43     myName = name;
  44     myParameterName = parameterName;
  45     myType = type;
  46   }
  47
  48   public static void createFromConstructor(final PsiMethod constructor, final Map<String, ParameterData> result) {
  49
  50     for (PsiParameter parameter : constructor.getParameterList().getParameters()) {
  51       initParameterData(parameter, result);
  52     }
  53
  54     final PsiMethod chainedConstructor = getChainedConstructor(constructor);
  55     if (chainedConstructor != null) {
  56       final PsiCodeBlock constructorBody = constructor.getBody();
  57       LOG.assertTrue(constructorBody != null);
  58       final PsiStatement thisStatement = constructorBody.getStatements()[0];
  59       final PsiExpression thisExpression = ((PsiExpressionStatement)thisStatement).getExpression();
  60       final PsiExpression[] args = ((PsiMethodCallExpression)thisExpression).getArgumentList().getExpressions();
  61       int i = 0;
  62       for (final PsiParameter parameter : chainedConstructor.getParameterList().getParameters()) {
  63         if (!parameter.isVarArgs()) {
  64           final ParameterData parameterData = initParameterData(parameter, result);
  65           parameterData.setDefaultValue(args[i++].getText());
  66         }
  67       }
  68     }
  69   }
  70
  71   @Nullable
  72   public static PsiMethod getChainedConstructor(PsiMethod constructor) {
  73     final PsiCodeBlock constructorBody = constructor.getBody();
  74     LOG.assertTrue(constructorBody != null);
  75     final PsiStatement[] statements = constructorBody.getStatements();
  76     if (statements.length == 1 && statements[0] instanceof PsiExpressionStatement) {
  77       final PsiExpression expression = ((PsiExpressionStatement)statements[0]).getExpression();
  78       if (expression instanceof PsiMethodCallExpression) {
  79         final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression)expression;
  80         final PsiReferenceExpression methodExpr = methodCallExpression.getMethodExpression();
  81         if ("this".equals(methodExpr.getReferenceName())) {
  82           return (PsiMethod)methodExpr.resolve();
  83         }
  84       }
  85     }
  86     return null;
  87   }
  88
  89   private static ParameterData initParameterData(PsiParameter parameter, Map<String, ParameterData> result) {
  90     JavaCodeStyleManager styleManager = JavaCodeStyleManager.getInstance(parameter.getProject());
  91     final String paramName = parameter.getName();
  92     final String pureParamName = styleManager.variableNameToPropertyName(paramName, VariableKind.PARAMETER);
  93
  94     ParameterData parameterData = result.get(pureParamName);
  95     if (parameterData == null) {
  96       parameterData = new ParameterData(pureParamName, paramName, parameter.getType());
  97
  98       parameterData.setFieldName(styleManager.suggestVariableName(VariableKind.FIELD, pureParamName, null, parameter.getType()).names[0]);
  99       parameterData.setSetterName(PropertyUtil.suggestSetterName(pureParamName));
 100
 101       result.put(pureParamName, parameterData);
 102     }
 103
 104     return parameterData;
 105   }
 106
 107   public PsiType getType() {
 108     return myType;
 109   }
 110
 111   public String getFieldName() {
 112     return myFieldName;
 113   }
 114
 115   public String getSetterName() {
 116     return mySetterName;
 117   }
 118
 119   public String getParamName() {
 120     return myParameterName;
 121   }
 122
 123   public String getDefaultValue() {
 124     return myDefaultValue;
 125   }
 126
 127   public boolean isInsertSetter() {
 128     return myInsertSetter;
 129   }
 130
 131   public void setFieldName(String fieldName) {
 132     myFieldName = fieldName;
 133   }
 134
 135   public void setSetterName(String setterName) {
 136     mySetterName = setterName;
 137   }
 138
 139   public void setDefaultValue(String defaultValue) {
 140     myDefaultValue = defaultValue;
 141   }
 142
 143   public void setInsertSetter(boolean insertSetter) {
 144     myInsertSetter = insertSetter;
 145   }
 146 }