java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateFieldFromUsageFix.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.codeInsight.daemon.impl.quickfix;
  17
  18 import com.intellij.codeInsight.CodeInsightUtilBase;
  19 import com.intellij.codeInsight.ExpectedTypeInfo;
  20 import com.intellij.codeInsight.daemon.QuickFixBundle;
  21 import com.intellij.codeInsight.template.Template;
  22 import com.intellij.codeInsight.template.TemplateBuilderImpl;
  23 import com.intellij.openapi.diagnostic.Logger;
  24 import com.intellij.openapi.editor.Editor;
  25 import com.intellij.openapi.project.Project;
  26 import com.intellij.openapi.util.TextRange;
  27 import com.intellij.psi.*;
  28 import com.intellij.psi.impl.source.codeStyle.CodeEditUtil;
  29 import com.intellij.psi.util.PsiTreeUtil;
  30 import com.intellij.psi.util.PsiUtil;
  31 import com.intellij.util.IncorrectOperationException;
  32 import org.jetbrains.annotations.NotNull;
  33
  34 /**
  35  * @author Mike
  36  */
  37 public class CreateFieldFromUsageFix extends CreateVarFromUsageFix {
  38   private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.daemon.impl.quickfix.CreateFieldFromUsageFix");
  39
  40   public CreateFieldFromUsageFix(PsiReferenceExpression referenceElement) {
  41     super(referenceElement);
  42   }
  43
  44   protected String getText(String varName) {
  45     return QuickFixBundle.message("create.field.from.usage.text", varName);
  46   }
  47
  48   protected boolean createConstantField() {
  49     return false;
  50   }
  51
  52   protected void invokeImpl(PsiClass targetClass) {
  53     if (CreateFromUsageUtils.isValidReference(myReferenceExpression, true)) {
  54       return;
  55     }
  56
  57     Project project = myReferenceExpression.getProject();
  58     PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory();
  59
  60
  61     PsiMember enclosingContext = null;
  62     PsiClass parentClass;
  63     do {
  64       enclosingContext = PsiTreeUtil.getParentOfType(enclosingContext == null ? myReferenceExpression : enclosingContext, PsiMethod.class,
  65                                                      PsiField.class, PsiClassInitializer.class);
  66       parentClass = enclosingContext == null ? null : enclosingContext.getContainingClass();
  67     }
  68     while (parentClass instanceof PsiAnonymousClass);
  69
  70     PsiFile targetFile = targetClass.getContainingFile();
  71
  72     try {
  73       ExpectedTypeInfo[] expectedTypes = CreateFromUsageUtils.guessExpectedTypes(myReferenceExpression, false);
  74
  75       String fieldName = myReferenceExpression.getReferenceName();
  76       PsiField field;
  77       if (!createConstantField()) {
  78         field = factory.createField(fieldName, PsiType.INT);
  79       } else {
  80         PsiClass aClass = factory.createClassFromText("int i = 0;", null);
  81         field = aClass.getFields()[0];
  82         field.setName(fieldName);
  83       }
  84       if (enclosingContext != null && enclosingContext.getParent() == parentClass && targetClass == parentClass
  85           && (enclosingContext instanceof PsiField)) {
  86         field = (PsiField)targetClass.addBefore(field, enclosingContext);
  87       }
  88       else if (enclosingContext != null && enclosingContext.getParent() == parentClass && targetClass == parentClass
  89           && (enclosingContext instanceof PsiClassInitializer)) {
  90         field = (PsiField)targetClass.addBefore(field, enclosingContext);
  91         targetClass.addBefore(CodeEditUtil.createLineFeed(field.getManager()), enclosingContext);
  92       }
  93       else {
  94         field = (PsiField)targetClass.add(field);
  95       }
  96
  97       setupVisibility(parentClass, targetClass, field.getModifierList());
  98
  99       if (shouldCreateStaticMember(myReferenceExpression, targetClass)) {
 100         PsiUtil.setModifierProperty(field, PsiModifier.STATIC, true);
 101       }
 102
 103       if (createConstantField()) {
 104         PsiUtil.setModifierProperty(field, PsiModifier.STATIC, true);
 105         PsiUtil.setModifierProperty(field, PsiModifier.FINAL, true);
 106       }
 107
 108       TemplateBuilderImpl builder = new TemplateBuilderImpl(field);
 109       PsiElement context = PsiTreeUtil.getParentOfType(myReferenceExpression, PsiClass.class, PsiMethod.class);
 110       new GuessTypeParameters(factory).setupTypeElement(field.getTypeElement(), expectedTypes, getTargetSubstitutor(myReferenceExpression),
 111                                                         builder, context, targetClass);
 112
 113       if (createConstantField()) {
 114         builder.replaceElement(field.getInitializer(), new EmptyExpression());
 115       }
 116
 117       builder.setEndVariableAfter(field.getNameIdentifier());
 118       field = CodeInsightUtilBase.forcePsiPostprocessAndRestoreElement(field);
 119       Template template = builder.buildTemplate();
 120
 121       Editor newEditor = positionCursor(project, targetFile, field);
 122       TextRange range = field.getTextRange();
 123       newEditor.getDocument().deleteString(range.getStartOffset(), range.getEndOffset());
 124
 125       startTemplate(newEditor, template, project);
 126     }
 127     catch (IncorrectOperationException e) {
 128       LOG.error(e);
 129     }
 130   }
 131
 132   @NotNull
 133   public String getFamilyName() {
 134     return QuickFixBundle.message("create.field.from.usage.family");
 135   }
 136 }