diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/DefaultQuickFixProvider.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/DefaultQuickFixProvider.java index f084d975b7a0..71b3176e7a29 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/DefaultQuickFixProvider.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/DefaultQuickFixProvider.java @@ -17,13 +17,20 @@ package com.intellij.codeInsight.daemon.impl.quickfix; import com.intellij.codeInsight.daemon.QuickFixActionRegistrar; import com.intellij.codeInsight.daemon.impl.analysis.HighlightMethodUtil; +import com.intellij.codeInsight.intention.IntentionAction; +import com.intellij.codeInsight.intention.impl.PriorityIntentionActionWrapper; import com.intellij.codeInsight.quickfix.UnresolvedReferenceQuickFixProvider; import com.intellij.openapi.util.TextRange; import com.intellij.psi.*; +import com.intellij.psi.codeStyle.JavaCodeStyleManager; +import com.intellij.psi.codeStyle.VariableKind; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtil; import org.jetbrains.annotations.NotNull; +import java.util.HashMap; +import java.util.Map; + public class DefaultQuickFixProvider extends UnresolvedReferenceQuickFixProvider { @Override public void registerFixes(PsiJavaCodeReferenceElement ref, QuickFixActionRegistrar registrar) { @@ -37,15 +44,13 @@ public class DefaultQuickFixProvider extends UnresolvedReferenceQuickFixProvider PsiReferenceExpression refExpr = (PsiReferenceExpression)ref; registrar.register(fixRange, new CreateEnumConstantFromUsageFix(refExpr), null); - registrar.register(fixRange, new CreateConstantFieldFromUsageFix(refExpr), null); - registrar.register(fixRange, new CreateFieldFromUsageFix(refExpr), null); registrar.register(new RenameWrongRefFix(refExpr)); if (!ref.isQualified()) { registrar.register(fixRange, new BringVariableIntoScopeFix(refExpr), null); - registrar.register(fixRange, new CreateLocalFromUsageFix(refExpr), null); - registrar.register(fixRange, new CreateParameterFromUsageFix(refExpr), null); } + + registerPriorityActions(registrar,fixRange,refExpr); } registrar.register(new CreateClassFromUsageFix(ref, CreateClassKind.INTERFACE)); @@ -65,6 +70,57 @@ public class DefaultQuickFixProvider extends UnresolvedReferenceQuickFixProvider } } + private static void registerPriorityActions(@NotNull final QuickFixActionRegistrar registrar, + @NotNull final TextRange fixRange, + @NotNull final PsiReferenceExpression refExpr) { + final JavaCodeStyleManager styleManager = JavaCodeStyleManager.getInstance(refExpr.getProject()); + + final Map map = new HashMap() { + { + put(VariableKind.FIELD, new CreateFieldFromUsageFix(refExpr)); + put(VariableKind.STATIC_FINAL_FIELD, new CreateConstantFieldFromUsageFix(refExpr)); + if (!refExpr.isQualified()) { + put(VariableKind.LOCAL_VARIABLE, new CreateLocalFromUsageFix(refExpr)); + put(VariableKind.PARAMETER, new CreateParameterFromUsageFix(refExpr)); + } + } + }; + + final VariableKind kind = getKind(styleManager, refExpr); + if (map.containsKey(kind)){ + map.put(kind, PriorityIntentionActionWrapper.highPriority(map.get(kind))); + } + + for (IntentionAction action : map.values()){ + registrar.register(fixRange, action, null); + } + } + + @NotNull + private static VariableKind getKind(@NotNull JavaCodeStyleManager styleManager, + @NotNull PsiReferenceExpression refExpr) { + final String reference = refExpr.getText(); + + if (reference.toUpperCase().equals(reference)){ + return VariableKind.STATIC_FINAL_FIELD; + } + + for (VariableKind kind : VariableKind.values()) { + final String prefix = styleManager.getPrefixByVariableKind(kind); + final String suffix = styleManager.getSuffixByVariableKind(kind); + + if (prefix.isEmpty() && suffix.isEmpty()) { + continue; + } + + if (reference.startsWith(prefix) && reference.endsWith(suffix)) { + return kind; + } + } + + return VariableKind.LOCAL_VARIABLE; + } + @Override @NotNull public Class getReferenceClass() { diff --git a/platform/lang-api/src/com/intellij/codeInsight/intention/impl/PriorityIntentionActionWrapper.java b/platform/lang-api/src/com/intellij/codeInsight/intention/impl/PriorityIntentionActionWrapper.java new file mode 100644 index 000000000000..4c6aa7cbb62d --- /dev/null +++ b/platform/lang-api/src/com/intellij/codeInsight/intention/impl/PriorityIntentionActionWrapper.java @@ -0,0 +1,96 @@ +/* + * Copyright 2000-2012 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.codeInsight.intention.impl; + +import com.intellij.codeInsight.intention.HighPriorityAction; +import com.intellij.codeInsight.intention.IntentionAction; +import com.intellij.codeInsight.intention.LowPriorityAction; +import com.intellij.openapi.editor.Editor; +import com.intellij.openapi.project.Project; +import com.intellij.psi.PsiFile; +import com.intellij.util.IncorrectOperationException; +import org.jetbrains.annotations.NotNull; + +/** + * @author Danila Ponomarenko + */ +public abstract class PriorityIntentionActionWrapper implements IntentionAction { + private IntentionAction action; + + private PriorityIntentionActionWrapper(@NotNull IntentionAction action) { + this.action = action; + } + + @NotNull + @Override + public String getText() { + return action.getText(); + } + + @NotNull + @Override + public String getFamilyName() { + return action.getFamilyName(); + } + + @Override + public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) { + return action.isAvailable(project, editor, file); + } + + @Override + public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException { + action.invoke(project, editor, file); + } + + @Override + public boolean startInWriteAction() { + return action.startInWriteAction(); + } + + private static class HighPriorityIntentionActionWrapper extends PriorityIntentionActionWrapper implements HighPriorityAction { + protected HighPriorityIntentionActionWrapper(@NotNull IntentionAction action) { + super(action); + } + } + + private static class NormalPriorityIntentionActionWrapper extends PriorityIntentionActionWrapper { + protected NormalPriorityIntentionActionWrapper(@NotNull IntentionAction action) { + super(action); + } + } + + private static class LowPriorityIntentionActionWrapper extends PriorityIntentionActionWrapper implements LowPriorityAction { + protected LowPriorityIntentionActionWrapper(@NotNull IntentionAction action) { + super(action); + } + } + + @NotNull + public static IntentionAction highPriority(@NotNull IntentionAction action) { + return new HighPriorityIntentionActionWrapper(action); + } + + @NotNull + public static IntentionAction normalPriority(@NotNull IntentionAction action) { + return new NormalPriorityIntentionActionWrapper(action); + } + + @NotNull + public static IntentionAction lowPriority(@NotNull IntentionAction action) { + return new LowPriorityIntentionActionWrapper(action); + } +} diff --git a/platform/lang-api/src/com/intellij/codeInsight/intention/impl/PriorityLocalQuickFixWrapper.java b/platform/lang-api/src/com/intellij/codeInsight/intention/impl/PriorityLocalQuickFixWrapper.java new file mode 100644 index 000000000000..ba83bc5b324c --- /dev/null +++ b/platform/lang-api/src/com/intellij/codeInsight/intention/impl/PriorityLocalQuickFixWrapper.java @@ -0,0 +1,85 @@ +/* + * Copyright 2000-2012 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.codeInsight.intention.impl; + +import com.intellij.codeInsight.intention.HighPriorityAction; +import com.intellij.codeInsight.intention.LowPriorityAction; +import com.intellij.codeInspection.LocalQuickFix; +import com.intellij.codeInspection.ProblemDescriptor; +import com.intellij.openapi.project.Project; +import org.jetbrains.annotations.NotNull; + +/** + * @author Danila Ponomarenko + */ +public abstract class PriorityLocalQuickFixWrapper implements LocalQuickFix { + private LocalQuickFix fix; + + private PriorityLocalQuickFixWrapper(@NotNull LocalQuickFix fix) { + this.fix = fix; + } + + @NotNull + @Override + public String getName() { + return fix.getName(); + } + + @NotNull + @Override + public String getFamilyName() { + return fix.getFamilyName(); + } + + @Override + public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { + fix.applyFix(project, descriptor); + } + + private static class HighPriorityLocalQuickFixWrapper extends PriorityLocalQuickFixWrapper implements HighPriorityAction { + protected HighPriorityLocalQuickFixWrapper(@NotNull LocalQuickFix fix) { + super(fix); + } + } + + private static class NormalPriorityLocalQuickFixWrapper extends PriorityLocalQuickFixWrapper { + protected NormalPriorityLocalQuickFixWrapper(@NotNull LocalQuickFix fix) { + super(fix); + } + } + + + private static class LowPriorityLocalQuickFixWrapper extends PriorityLocalQuickFixWrapper implements LowPriorityAction { + protected LowPriorityLocalQuickFixWrapper(@NotNull LocalQuickFix fix) { + super(fix); + } + } + + @NotNull + public static LocalQuickFix highPriority(@NotNull LocalQuickFix fix) { + return new HighPriorityLocalQuickFixWrapper(fix); + } + + @NotNull + public static LocalQuickFix normalPriority(@NotNull LocalQuickFix fix) { + return new NormalPriorityLocalQuickFixWrapper(fix); + } + + @NotNull + public static LocalQuickFix lowPriority(@NotNull LocalQuickFix fix) { + return new LowPriorityLocalQuickFixWrapper(fix); + } +}