Cleanup: NotNull/Nullable
[idea/community.git] / java / java-impl / src / com / intellij / codeInsight / intention / impl / config / QuickFixFactoryImpl.java
1 // Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
2 package com.intellij.codeInsight.intention.impl.config;
3
4 import com.intellij.codeInsight.CodeInsightWorkspaceSettings;
5 import com.intellij.codeInsight.daemon.HighlightDisplayKey;
6 import com.intellij.codeInsight.daemon.QuickFixActionRegistrar;
7 import com.intellij.codeInsight.daemon.QuickFixBundle;
8 import com.intellij.codeInsight.daemon.impl.*;
9 import com.intellij.codeInsight.daemon.impl.analysis.IncreaseLanguageLevelFix;
10 import com.intellij.codeInsight.daemon.impl.quickfix.*;
11 import com.intellij.codeInsight.daemon.quickFix.CreateClassOrPackageFix;
12 import com.intellij.codeInsight.daemon.quickFix.CreateFieldOrPropertyFix;
13 import com.intellij.codeInsight.intention.IntentionAction;
14 import com.intellij.codeInsight.intention.IntentionManager;
15 import com.intellij.codeInsight.intention.QuickFixFactory;
16 import com.intellij.codeInsight.intention.impl.*;
17 import com.intellij.codeInspection.*;
18 import com.intellij.codeInspection.deadCode.UnusedDeclarationInspectionBase;
19 import com.intellij.codeInspection.ex.EntryPointsManagerBase;
20 import com.intellij.codeInspection.unusedSymbol.UnusedSymbolLocalInspectionBase;
21 import com.intellij.codeInspection.util.SpecialAnnotationsUtil;
22 import com.intellij.diagnostic.AttachmentFactory;
23 import com.intellij.lang.annotation.HighlightSeverity;
24 import com.intellij.lang.java.request.CreateConstructorFromUsage;
25 import com.intellij.lang.java.request.CreateMethodFromUsage;
26 import com.intellij.lang.jvm.actions.JvmElementActionFactories;
27 import com.intellij.openapi.application.ApplicationManager;
28 import com.intellij.openapi.diagnostic.Logger;
29 import com.intellij.openapi.editor.Document;
30 import com.intellij.openapi.editor.Editor;
31 import com.intellij.openapi.module.Module;
32 import com.intellij.openapi.project.Project;
33 import com.intellij.openapi.util.Comparing;
34 import com.intellij.openapi.util.TextRange;
35 import com.intellij.pom.java.LanguageLevel;
36 import com.intellij.profile.codeInspection.InspectionProjectProfileManager;
37 import com.intellij.psi.*;
38 import com.intellij.psi.codeStyle.JavaCodeStyleManager;
39 import com.intellij.psi.tree.IElementType;
40 import com.intellij.psi.util.ClassKind;
41 import com.intellij.psi.util.InheritanceUtil;
42 import com.intellij.psi.util.PropertyMemberType;
43 import com.intellij.refactoring.memberPushDown.JavaPushDownHandler;
44 import com.intellij.util.DocumentUtil;
45 import com.intellij.util.IncorrectOperationException;
46 import com.siyeh.ig.fixes.CreateDefaultBranchFix;
47 import com.siyeh.ig.fixes.CreateMissingSwitchBranchesFix;
48 import org.jetbrains.annotations.Nls;
49 import org.jetbrains.annotations.NotNull;
50 import org.jetbrains.annotations.Nullable;
51
52 import java.util.*;
53
54 /**
55  * @author cdr
56  */
57 public class QuickFixFactoryImpl extends QuickFixFactory {
58   private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.intention.impl.config.QuickFixFactoryImpl");
59
60   @NotNull
61   @Override
62   public LocalQuickFixAndIntentionActionOnPsiElement createModifierListFix(@NotNull PsiModifierList modifierList,
63                                                                            @NotNull String modifier,
64                                                                            boolean shouldHave,
65                                                                            boolean showContainingClass) {
66     return new ModifierFix(modifierList, modifier, shouldHave,showContainingClass);
67   }
68
69   @NotNull
70   @Override
71   public LocalQuickFixAndIntentionActionOnPsiElement createModifierListFix(@NotNull PsiModifierListOwner owner,
72                                                                            @NotNull final String modifier,
73                                                                            final boolean shouldHave,
74                                                                            final boolean showContainingClass) {
75     return new ModifierFix(owner, modifier, shouldHave, showContainingClass);
76   }
77
78   @NotNull
79   @Override
80   public LocalQuickFixAndIntentionActionOnPsiElement createMethodReturnFix(@NotNull PsiMethod method,
81                                                                            @NotNull PsiType toReturn,
82                                                                            boolean fixWholeHierarchy) {
83     return new MethodReturnTypeFix(method, toReturn, fixWholeHierarchy);
84   }
85
86   @NotNull
87   @Override
88   public LocalQuickFixAndIntentionActionOnPsiElement createAddMethodFix(@NotNull PsiMethod method, @NotNull PsiClass toClass) {
89     return new AddMethodFix(method, toClass);
90   }
91
92   @NotNull
93   @Override
94   public LocalQuickFixAndIntentionActionOnPsiElement createAddMethodFix(@NotNull String methodText,
95                                                                         @NotNull PsiClass toClass,
96                                                                         @NotNull String... exceptions) {
97     return new AddMethodFix(methodText, toClass, exceptions);
98   }
99
100   @NotNull
101   @Override
102   public LocalQuickFixAndIntentionActionOnPsiElement createImplementMethodsFix(@NotNull PsiClass aClass) {
103     return new ImplementMethodsFix(aClass);
104   }
105
106   @NotNull
107   @Override
108   public LocalQuickFixAndIntentionActionOnPsiElement createImplementMethodsFix(@NotNull PsiElement psiElement) {
109     return new ImplementMethodsFix(psiElement);
110   }
111
112   @NotNull
113   @Override
114   public LocalQuickFixAndIntentionActionOnPsiElement createAssignmentToComparisonFix(@NotNull PsiAssignmentExpression expr) {
115     return new ReplaceAssignmentWithComparisonFix(expr);
116   }
117
118   @NotNull
119   @Override
120   public LocalQuickFixOnPsiElement createMethodThrowsFix(@NotNull PsiMethod method,
121                                                          @NotNull PsiClassType exceptionClass,
122                                                          boolean shouldThrow,
123                                                          boolean showContainingClass) {
124     return shouldThrow ? new MethodThrowsFix.Add(method, exceptionClass, showContainingClass) : new MethodThrowsFix.Remove(method, exceptionClass, showContainingClass);
125   }
126
127   @NotNull
128   @Override
129   public LocalQuickFixAndIntentionActionOnPsiElement createAddDefaultConstructorFix(@NotNull PsiClass aClass) {
130     return new AddDefaultConstructorFix(aClass);
131   }
132
133   @Override
134   public LocalQuickFixAndIntentionActionOnPsiElement createAddConstructorFix(@NotNull PsiClass aClass, @NotNull String modifier) {
135     return aClass.getName() != null ? new AddDefaultConstructorFix(aClass, modifier) : null;
136   }
137
138   @NotNull
139   @Override
140   public LocalQuickFixAndIntentionActionOnPsiElement createMethodParameterTypeFix(@NotNull PsiMethod method,
141                                                                                   int index,
142                                                                                   @NotNull PsiType newType,
143                                                                                   boolean fixWholeHierarchy) {
144     return new MethodParameterFix(method, newType, index, fixWholeHierarchy);
145   }
146
147   @NotNull
148   @Override
149   public LocalQuickFixAndIntentionActionOnPsiElement createMakeClassInterfaceFix(@NotNull PsiClass aClass) {
150     return new MakeClassInterfaceFix(aClass, true);
151   }
152
153   @NotNull
154   @Override
155   public LocalQuickFixAndIntentionActionOnPsiElement createMakeClassInterfaceFix(@NotNull PsiClass aClass, final boolean makeInterface) {
156     return new MakeClassInterfaceFix(aClass, makeInterface);
157   }
158
159   @NotNull
160   @Override
161   public LocalQuickFixAndIntentionActionOnPsiElement createExtendsListFix(@NotNull PsiClass aClass,
162                                                                           @NotNull PsiClassType typeToExtendFrom,
163                                                                           boolean toAdd) {
164     return new ExtendsListFix(aClass, typeToExtendFrom, toAdd);
165   }
166
167   @NotNull
168   @Override
169   public LocalQuickFixAndIntentionActionOnPsiElement createRemoveUnusedParameterFix(@NotNull PsiParameter parameter) {
170     return new RemoveUnusedParameterFix(parameter);
171   }
172
173   @NotNull
174   @Override
175   public IntentionAction createRemoveUnusedVariableFix(@NotNull PsiVariable variable) {
176     return new RemoveUnusedVariableFix(variable);
177   }
178
179   @Override
180   @Nullable
181   public IntentionAction createCreateClassOrPackageFix(@NotNull final PsiElement context, @NotNull final String qualifiedName, final boolean createClass, final String superClass) {
182     return CreateClassOrPackageFix.createFix(qualifiedName, context, createClass ? ClassKind.CLASS : null, superClass);
183   }
184
185   @Override
186   @Nullable
187   public IntentionAction createCreateClassOrInterfaceFix(@NotNull final PsiElement context, @NotNull final String qualifiedName, final boolean createClass, final String superClass) {
188     return CreateClassOrPackageFix.createFix(qualifiedName, context, createClass ? ClassKind.CLASS : ClassKind.INTERFACE, superClass);
189   }
190
191   @NotNull
192   @Override
193   public IntentionAction createCreateFieldOrPropertyFix(@NotNull final PsiClass aClass, @NotNull final String name, @NotNull final PsiType type, @NotNull final PropertyMemberType targetMember, @NotNull final PsiAnnotation... annotations) {
194     return new CreateFieldOrPropertyFix(aClass, name, type, targetMember, annotations);
195   }
196
197   @NotNull
198   @Override
199   public IntentionAction createSetupJDKFix() {
200     return SetupJDKFix.getInstance();
201   }
202
203   @NotNull
204   @Override
205   public IntentionAction createAddExceptionToCatchFix() {
206     return new AddExceptionToCatchFix(true);
207   }
208
209   @NotNull
210   @Override
211   public IntentionAction createAddExceptionToThrowsFix(@NotNull PsiElement element) {
212     return new AddExceptionToThrowsFix(element);
213   }
214
215   @NotNull
216   @Override
217   public IntentionAction createAddExceptionFromFieldInitializerToConstructorThrowsFix(@NotNull PsiElement element) {
218     return new AddExceptionFromFieldInitializerToConstructorThrowsFix(element);
219   }
220
221   @NotNull
222   @Override
223   public IntentionAction createSurroundWithTryCatchFix(@NotNull PsiElement element) {
224     return new SurroundWithTryCatchFix(element);
225   }
226
227   @NotNull
228   @Override
229   public IntentionAction createAddExceptionToExistingCatch(@NotNull PsiElement element) {
230     return new AddExceptionToExistingCatchFix(element);
231   }
232
233   @NotNull
234   @Override
235   public IntentionAction createChangeToAppendFix(@NotNull IElementType sign,
236                                                  @NotNull PsiType type,
237                                                  @NotNull PsiAssignmentExpression assignment) {
238     return new ChangeToAppendFix(sign, type, assignment);
239   }
240
241   @NotNull
242   @Override
243   public IntentionAction createAddTypeCastFix(@NotNull PsiType type, @NotNull PsiExpression expression) {
244     return new AddTypeCastFix(type, expression);
245   }
246
247   @NotNull
248   @Override
249   public IntentionAction createWrapExpressionFix(@NotNull PsiType type, @NotNull PsiExpression expression) {
250     return new WrapExpressionFix(type, expression);
251   }
252
253   @NotNull
254   @Override
255   public IntentionAction createReuseVariableDeclarationFix(@NotNull PsiLocalVariable variable) {
256     return new ReuseVariableDeclarationFix(variable);
257   }
258
259   @NotNull
260   @Override
261   public IntentionAction createNavigateToAlreadyDeclaredVariableFix(@NotNull PsiVariable variable) {
262     return new NavigateToAlreadyDeclaredVariableFix(variable);
263   }
264
265   @NotNull
266   @Override
267   public IntentionAction createConvertToStringLiteralAction() {
268     return new ConvertToStringLiteralAction();
269   }
270
271   @NotNull
272   @Override
273   public IntentionAction createDeleteCatchFix(@NotNull PsiParameter parameter) {
274     return new DeleteCatchFix(parameter);
275   }
276
277   @NotNull
278   @Override
279   public IntentionAction createDeleteMultiCatchFix(@NotNull PsiTypeElement element) {
280     return new DeleteMultiCatchFix(element);
281   }
282
283   @NotNull
284   @Override
285   public IntentionAction createConvertSwitchToIfIntention(@NotNull PsiSwitchStatement statement) {
286     return new ConvertSwitchToIfIntention(statement);
287   }
288
289   @NotNull
290   @Override
291   public IntentionAction createNegationBroadScopeFix(@NotNull PsiPrefixExpression expr) {
292     return new NegationBroadScopeFix(expr);
293   }
294
295   @NotNull
296   @Override
297   public IntentionAction createCreateFieldFromUsageFix(@NotNull PsiReferenceExpression place) {
298     return new CreateFieldFromUsageFix(place);
299   }
300
301   @NotNull
302   @Override
303   public IntentionAction createReplaceWithListAccessFix(@NotNull PsiArrayAccessExpression expression) {
304     return new ReplaceWithListAccessFix(expression);
305   }
306
307   @NotNull
308   @Override
309   public IntentionAction createAddNewArrayExpressionFix(@NotNull PsiArrayInitializerExpression expression) {
310     return new AddNewArrayExpressionFix(expression);
311   }
312
313   @NotNull
314   @Override
315   public IntentionAction createMoveCatchUpFix(@NotNull PsiCatchSection section, @NotNull PsiCatchSection section1) {
316     return new MoveCatchUpFix(section, section1);
317   }
318
319   @NotNull
320   @Override
321   public IntentionAction createRenameWrongRefFix(@NotNull PsiReferenceExpression ref) {
322     return new RenameWrongRefFix(ref);
323   }
324
325   @NotNull
326   @Override
327   public IntentionAction createRemoveQualifierFix(@NotNull PsiExpression qualifier,
328                                                   @NotNull PsiReferenceExpression expression,
329                                                   @NotNull PsiClass resolved) {
330     return new RemoveQualifierFix(qualifier, expression, resolved);
331   }
332
333   @NotNull
334   @Override
335   public IntentionAction createRemoveParameterListFix(@NotNull PsiMethod parent) {
336     return new RemoveParameterListFix(parent);
337   }
338
339   @NotNull
340   @Override
341   public IntentionAction createShowModulePropertiesFix(@NotNull PsiElement element) {
342     return new ShowModulePropertiesFix(element);
343   }
344   @NotNull
345   @Override
346   public IntentionAction createShowModulePropertiesFix(@NotNull Module module) {
347     return new ShowModulePropertiesFix(module);
348   }
349
350   @NotNull
351   @Override
352   public IntentionAction createIncreaseLanguageLevelFix(@NotNull LanguageLevel level) {
353     return new IncreaseLanguageLevelFix(level);
354   }
355
356   @NotNull
357   @Override
358   public IntentionAction createChangeParameterClassFix(@NotNull PsiClass aClass, @NotNull PsiClassType type) {
359     return new ChangeParameterClassFix(aClass, type);
360   }
361
362   @NotNull
363   @Override
364   public IntentionAction createReplaceInaccessibleFieldWithGetterSetterFix(@NotNull PsiElement element, @NotNull PsiMethod getter, boolean isSetter) {
365     return new ReplaceInaccessibleFieldWithGetterSetterFix(element, getter, isSetter);
366   }
367
368   @NotNull
369   @Override
370   public IntentionAction createSurroundWithArrayFix(@Nullable PsiCall methodCall, @Nullable PsiExpression expression) {
371     return new SurroundWithArrayFix(methodCall, expression);
372   }
373
374   @NotNull
375   @Override
376   public IntentionAction createImplementAbstractClassMethodsFix(@NotNull PsiElement elementToHighlight) {
377     return new ImplementAbstractClassMethodsFix(elementToHighlight);
378   }
379
380   @NotNull
381   @Override
382   public IntentionAction createMoveClassToSeparateFileFix(@NotNull PsiClass aClass) {
383     return new MoveClassToSeparateFileFix(aClass);
384   }
385
386   @NotNull
387   @Override
388   public IntentionAction createRenameFileFix(@NotNull String newName) {
389     return new RenameFileFix(newName);
390   }
391
392   @NotNull
393   @Override
394   public LocalQuickFixAndIntentionActionOnPsiElement createRenameElementFix(@NotNull PsiNamedElement element) {
395     return new RenameElementFix(element);
396   }
397
398   @NotNull
399   @Override
400   public LocalQuickFixAndIntentionActionOnPsiElement createRenameElementFix(@NotNull PsiNamedElement element, @NotNull String newName) {
401     return new RenameElementFix(element, newName);
402   }
403
404   @NotNull
405   @Override
406   public IntentionAction createChangeExtendsToImplementsFix(@NotNull PsiClass aClass, @NotNull PsiClassType classToExtendFrom) {
407     return new ChangeExtendsToImplementsFix(aClass, classToExtendFrom);
408   }
409
410   @NotNull
411   @Override
412   public IntentionAction createCreateConstructorMatchingSuperFix(@NotNull PsiClass aClass) {
413     return new CreateConstructorMatchingSuperFix(aClass);
414   }
415
416   @NotNull
417   @Override
418   public IntentionAction createRemoveNewQualifierFix(@NotNull PsiNewExpression expression, PsiClass aClass) {
419     return new RemoveNewQualifierFix(expression, aClass);
420   }
421
422   @NotNull
423   @Override
424   public IntentionAction createSuperMethodReturnFix(@NotNull PsiMethod superMethod, @NotNull PsiType superMethodType) {
425     return new SuperMethodReturnFix(superMethod, superMethodType);
426   }
427
428   @NotNull
429   @Override
430   public IntentionAction createInsertNewFix(@NotNull PsiMethodCallExpression call, @NotNull PsiClass aClass) {
431     return new InsertNewFix(call, aClass);
432   }
433
434   @NotNull
435   @Override
436   public IntentionAction createAddMethodBodyFix(@NotNull PsiMethod method) {
437     return new AddMethodBodyFix(method);
438   }
439
440   @NotNull
441   @Override
442   public IntentionAction createDeleteMethodBodyFix(@NotNull PsiMethod method) {
443     return new DeleteMethodBodyFix(method);
444   }
445
446   @NotNull
447   @Override
448   public IntentionAction createInsertSuperFix(@NotNull PsiMethod constructor) {
449     return new InsertSuperFix(constructor);
450   }
451
452   @NotNull
453   @Override
454   public IntentionAction createInsertThisFix(@NotNull PsiMethod constructor) {
455     return new InsertThisFix(constructor);
456   }
457
458   @NotNull
459   @Override
460   public IntentionAction createChangeMethodSignatureFromUsageFix(@NotNull PsiMethod targetMethod,
461                                                                  @NotNull PsiExpression[] expressions,
462                                                                  @NotNull PsiSubstitutor substitutor,
463                                                                  @NotNull PsiElement context,
464                                                                  boolean changeAllUsages,
465                                                                  int minUsagesNumberToShowDialog) {
466     return new ChangeMethodSignatureFromUsageFix(targetMethod, expressions, substitutor, context, changeAllUsages, minUsagesNumberToShowDialog);
467   }
468
469   @NotNull
470   @Override
471   public IntentionAction createChangeMethodSignatureFromUsageReverseOrderFix(@NotNull PsiMethod targetMethod,
472                                                                              @NotNull PsiExpression[] expressions,
473                                                                              @NotNull PsiSubstitutor substitutor,
474                                                                              @NotNull PsiElement context,
475                                                                              boolean changeAllUsages,
476                                                                              int minUsagesNumberToShowDialog) {
477     return new ChangeMethodSignatureFromUsageReverseOrderFix(targetMethod, expressions, substitutor, context, changeAllUsages, minUsagesNumberToShowDialog);
478   }
479
480   @NotNull
481   @Override
482   public List<IntentionAction> createCreateMethodFromUsageFixes(@NotNull PsiMethodCallExpression call) {
483     return CreateMethodFromUsage.generateActions(call);
484   }
485
486   @NotNull
487   @Override
488   public IntentionAction createCreateMethodFromUsageFix(@NotNull PsiMethodCallExpression call) {
489     return new CreateMethodFromUsageFix(call);
490   }
491
492   @NotNull
493   @Override
494   public IntentionAction createCreateMethodFromUsageFix(@NotNull PsiMethodReferenceExpression methodReferenceExpression) {
495     return new CreateMethodFromMethodReferenceFix(methodReferenceExpression);
496   }
497
498   @NotNull
499   @Override
500   public IntentionAction createCreateAbstractMethodFromUsageFix(@NotNull PsiMethodCallExpression call) {
501     return new CreateAbstractMethodFromUsageFix(call);
502   }
503
504   @NotNull
505   @Override
506   public IntentionAction createCreatePropertyFromUsageFix(@NotNull PsiMethodCallExpression call) {
507     return new CreatePropertyFromUsageFix(call);
508   }
509
510   @NotNull
511   @Override
512   public IntentionAction createCreateConstructorFromSuperFix(@NotNull PsiMethodCallExpression call) {
513     return new CreateConstructorFromSuperFix(call);
514   }
515
516   @NotNull
517   @Override
518   public IntentionAction createCreateConstructorFromThisFix(@NotNull PsiMethodCallExpression call) {
519     return new CreateConstructorFromThisFix(call);
520   }
521
522   @NotNull
523   @Override
524   public List<IntentionAction> createCreateConstructorFromCallExpressionFixes(@NotNull PsiMethodCallExpression call) {
525     if (JvmElementActionFactories.useInterlaguageActions()) {
526       return CreateConstructorFromUsage.generateConstructorActions(call);
527     }
528     return Arrays.asList(
529       createCreateConstructorFromSuperFix(call),
530       createCreateConstructorFromThisFix(call)
531     );
532   }
533
534   @NotNull
535   @Override
536   public IntentionAction createCreateGetterSetterPropertyFromUsageFix(@NotNull PsiMethodCallExpression call) {
537     return new CreateGetterSetterPropertyFromUsageFix(call);
538   }
539
540   @NotNull
541   @Override
542   public IntentionAction createStaticImportMethodFix(@NotNull PsiMethodCallExpression call) {
543     return new StaticImportMethodFix(call.getContainingFile(), call);
544   }
545
546   @NotNull
547   @Override
548   public IntentionAction createQualifyStaticMethodCallFix(@NotNull PsiMethodCallExpression call) {
549     return new QualifyStaticMethodCallFix(call.getContainingFile(), call);
550   }
551
552   @NotNull
553   @Override
554   public IntentionAction createReplaceAddAllArrayToCollectionFix(@NotNull PsiMethodCallExpression call) {
555     return new ReplaceAddAllArrayToCollectionFix(call);
556   }
557
558   @NotNull
559   @Override
560   public IntentionAction createCreateConstructorFromCallFix(@NotNull PsiConstructorCall call) {
561     return new CreateConstructorFromCallFix(call);
562   }
563
564   @NotNull
565   @Override
566   public List<IntentionAction> createCreateConstructorFromUsageFixes(@NotNull PsiConstructorCall call) {
567     if (JvmElementActionFactories.useInterlaguageActions()) {
568       return CreateConstructorFromUsage.generateConstructorActions(call);
569     }
570     return Collections.singletonList(createCreateConstructorFromCallFix(call));
571   }
572
573   @NotNull
574   @Override
575   public List<IntentionAction> getVariableTypeFromCallFixes(@NotNull PsiMethodCallExpression call, @NotNull PsiExpressionList list) {
576     return VariableTypeFromCallFix.getQuickFixActions(call, list);
577   }
578
579   @NotNull
580   @Override
581   public IntentionAction createAddReturnFix(@NotNull PsiParameterListOwner methodOrLambda) {
582     return new AddReturnFix(methodOrLambda);
583   }
584
585   @NotNull
586   @Override
587   public IntentionAction createAddVariableInitializerFix(@NotNull PsiVariable variable) {
588     return new AddVariableInitializerFix(variable);
589   }
590
591   @NotNull
592   @Override
593   public IntentionAction createDeferFinalAssignmentFix(@NotNull PsiVariable variable, @NotNull PsiReferenceExpression expression) {
594     return new DeferFinalAssignmentFix(variable, expression);
595   }
596
597   @NotNull
598   @Override
599   public IntentionAction createVariableAccessFromInnerClassFix(@NotNull PsiVariable variable, @NotNull PsiElement scope) {
600     return new VariableAccessFromInnerClassFix(variable, scope);
601   }
602
603   @NotNull
604   @Override
605   public IntentionAction createCreateConstructorParameterFromFieldFix(@NotNull PsiField field) {
606     return new CreateConstructorParameterFromFieldFix(field);
607   }
608
609   @NotNull
610   @Override
611   public IntentionAction createInitializeFinalFieldInConstructorFix(@NotNull PsiField field) {
612     return new InitializeFinalFieldInConstructorFix(field);
613   }
614
615   @NotNull
616   @Override
617   public IntentionAction createRemoveTypeArgumentsFix(@NotNull PsiElement variable) {
618     return new RemoveTypeArgumentsFix(variable);
619   }
620
621   @NotNull
622   @Override
623   public IntentionAction createChangeClassSignatureFromUsageFix(@NotNull PsiClass owner, @NotNull PsiReferenceParameterList parameterList) {
624     return new ChangeClassSignatureFromUsageFix(owner, parameterList);
625   }
626
627   @NotNull
628   @Override
629   public IntentionAction createReplacePrimitiveWithBoxedTypeAction(@NotNull PsiTypeElement element, @NotNull String typeName, @NotNull String boxedTypeName) {
630     return new ReplacePrimitiveWithBoxedTypeAction(element, typeName, boxedTypeName);
631   }
632
633   @NotNull
634   @Override
635   public IntentionAction createMakeVarargParameterLastFix(@NotNull PsiParameter parameter) {
636     return new MakeVarargParameterLastFix(parameter);
637   }
638
639   @NotNull
640   @Override
641   public IntentionAction createMoveBoundClassToFrontFix(@NotNull PsiClass aClass, @NotNull PsiClassType type) {
642     return new MoveBoundClassToFrontFix(aClass, type);
643   }
644
645   @Override
646   public void registerPullAsAbstractUpFixes(@NotNull PsiMethod method, @NotNull QuickFixActionRegistrar registrar) {
647     PullAsAbstractUpFix.registerQuickFix(method, registrar);
648   }
649
650   @NotNull
651   @Override
652   public IntentionAction createCreateAnnotationMethodFromUsageFix(@NotNull PsiNameValuePair pair) {
653     return new CreateAnnotationMethodFromUsageFix(pair);
654   }
655
656   @NotNull
657   @Override
658   public IntentionAction createOptimizeImportsFix(final boolean onTheFly) {
659     return new IntentionAction() {
660       @NotNull
661       @Override
662       public String getText() {
663         return QuickFixBundle.message("optimize.imports.fix");
664       }
665
666       @NotNull
667       @Override
668       public String getFamilyName() {
669         return QuickFixBundle.message("optimize.imports.fix");
670       }
671
672       @Override
673       public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
674         return (!onTheFly || timeToOptimizeImports(file)) && file instanceof PsiJavaFile && BaseIntentionAction.canModify(file);
675       }
676
677       @Override
678       public void invoke(@NotNull final Project project, final Editor editor, final PsiFile file) throws IncorrectOperationException {
679         invokeOnTheFlyImportOptimizer(file);
680       }
681
682       @Override
683       public boolean startInWriteAction() {
684         return true;
685       }
686     };
687   }
688
689   @Override
690   public void registerFixesForUnusedParameter(@NotNull PsiParameter parameter, @NotNull Object highlightInfo) {
691     Project myProject = parameter.getProject();
692     InspectionProfile profile = InspectionProjectProfileManager.getInstance(myProject).getCurrentProfile();
693     UnusedDeclarationInspectionBase unusedParametersInspection =
694       (UnusedDeclarationInspectionBase)profile.getUnwrappedTool(UnusedSymbolLocalInspectionBase.SHORT_NAME, parameter);
695     LOG.assertTrue(ApplicationManager.getApplication().isUnitTestMode() || unusedParametersInspection != null);
696     HighlightDisplayKey myUnusedSymbolKey = HighlightDisplayKey.find(UnusedSymbolLocalInspectionBase.SHORT_NAME);
697     List<IntentionAction> options =
698       new ArrayList<>(IntentionManager.getInstance().getStandardIntentionOptions(myUnusedSymbolKey, parameter));
699     if (unusedParametersInspection != null) {
700       SuppressQuickFix[] batchSuppressActions = unusedParametersInspection.getBatchSuppressActions(parameter);
701       Collections.addAll(options, SuppressIntentionActionFromFix.convertBatchToSuppressIntentionActions(batchSuppressActions));
702     }
703     //need suppress from Unused Parameters but settings from Unused Symbol
704     QuickFixAction.registerQuickFixAction((HighlightInfo)highlightInfo, new SafeDeleteFix(parameter),
705                                           options, HighlightDisplayKey.getDisplayNameByKey(myUnusedSymbolKey));
706   }
707
708   @NotNull
709   @Override
710   public IntentionAction createAddToDependencyInjectionAnnotationsFix(@NotNull Project project,
711                                                                       @NotNull String qualifiedName) {
712     final EntryPointsManagerBase entryPointsManager = EntryPointsManagerBase.getInstance(project);
713     return SpecialAnnotationsUtil.createAddToSpecialAnnotationsListIntentionAction(
714       QuickFixBundle.message("fix.unused.symbol.injection.text", qualifiedName),
715       QuickFixBundle.message("fix.unused.symbol.injection.family"),
716       entryPointsManager.ADDITIONAL_ANNOTATIONS, qualifiedName);
717   }
718
719   @NotNull
720   @Override
721   public IntentionAction createAddToImplicitlyWrittenFieldsFix(@NotNull Project project, @NotNull final String qualifiedName) {
722     EntryPointsManagerBase entryPointsManagerBase = EntryPointsManagerBase.getInstance(project);
723     return entryPointsManagerBase.new AddImplicitlyWriteAnnotation(qualifiedName);
724   }
725
726   @NotNull
727   @Override
728   public IntentionAction createCreateGetterOrSetterFix(boolean createGetter, boolean createSetter, @NotNull PsiField field) {
729     return new CreateGetterOrSetterFix(createGetter, createSetter, field);
730   }
731
732   @NotNull
733   @Override
734   public IntentionAction createRenameToIgnoredFix(@NotNull PsiNamedElement namedElement) {
735     return new RenameToIgnoredFix(namedElement);
736   }
737
738   @NotNull
739   @Override
740   public IntentionAction createEnableOptimizeImportsOnTheFlyFix() {
741     return new EnableOptimizeImportsOnTheFlyFix();
742   }
743
744   @NotNull
745   @Override
746   public LocalQuickFixAndIntentionActionOnPsiElement createDeleteFix(@NotNull PsiElement element) {
747     return new DeleteElementFix(element);
748   }
749
750   @NotNull
751   @Override
752   public LocalQuickFixAndIntentionActionOnPsiElement createDeleteFix(@NotNull PsiElement element, @Nls @NotNull String text) {
753     return new DeleteElementFix(element, text);
754   }
755
756   @NotNull
757   @Override
758   public IntentionAction createSafeDeleteFix(@NotNull PsiElement element) {
759     return new SafeDeleteFix(element);
760   }
761
762   @Nullable
763   @Override
764   public List<LocalQuickFix> registerOrderEntryFixes(@NotNull QuickFixActionRegistrar registrar, @NotNull PsiReference reference) {
765     return OrderEntryFix.registerFixes(registrar, reference);
766   }
767
768   private static void invokeOnTheFlyImportOptimizer(@NotNull PsiFile file) {
769     final Project project = file.getProject();
770     final Document document = PsiDocumentManager.getInstance(project).getDocument(file);
771     if (document == null) return;
772
773     String beforeText = file.getText();
774     long oldStamp = document.getModificationStamp();
775     DocumentUtil.writeInRunUndoTransparentAction(() -> JavaCodeStyleManager.getInstance(project).optimizeImports(file));
776     if (oldStamp != document.getModificationStamp()) {
777       String afterText = file.getText();
778       if (Comparing.strEqual(beforeText, afterText)) {
779         LOG.error("Import optimizer hasn't optimized any imports",
780                   new Throwable(file.getViewProvider().getVirtualFile().getPath()),
781                   AttachmentFactory.createAttachment(file.getViewProvider().getVirtualFile()));
782       }
783     }
784   }
785
786   @NotNull
787   @Override
788   public IntentionAction createAddMissingRequiredAnnotationParametersFix(@NotNull final PsiAnnotation annotation,
789                                                                          @NotNull final PsiMethod[] annotationMethods,
790                                                                          @NotNull final Collection<String> missedElements) {
791     return new AddMissingRequiredAnnotationParametersFix(annotation, annotationMethods, missedElements);
792   }
793
794   @NotNull
795   @Override
796   public IntentionAction createSurroundWithQuotesAnnotationParameterValueFix(@NotNull PsiAnnotationMemberValue value,
797                                                                              @NotNull PsiType expectedType) {
798     return new SurroundWithQuotesAnnotationParameterValueFix(value, expectedType);
799   }
800
801   @NotNull
802   @Override
803   public IntentionAction addMethodQualifierFix(@NotNull PsiMethodCallExpression methodCall) {
804     return new AddMethodQualifierFix(methodCall);
805   }
806
807   @NotNull
808   @Override
809   public IntentionAction createWrapWithOptionalFix(@Nullable PsiType type, @NotNull PsiExpression expression) {
810     return WrapObjectWithOptionalOfNullableFix.createFix(type, expression);
811   }
812
813   @Nullable
814   @Override
815   public IntentionAction createNotIterableForEachLoopFix(@NotNull PsiExpression expression) {
816     final PsiElement parent = expression.getParent();
817     if (parent instanceof PsiForeachStatement) {
818       final PsiType type = expression.getType();
819       if (InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_UTIL_ITERATOR)) {
820         return new ReplaceIteratorForEachLoopWithIteratorForLoopFix((PsiForeachStatement)parent);
821       }
822     }
823     return null;
824   }
825
826   @NotNull
827   @Override
828   public List<IntentionAction> createAddAnnotationAttributeNameFixes(@NotNull PsiNameValuePair pair) {
829     return AddAnnotationAttributeNameFix.createFixes(pair);
830   }
831
832   private static boolean timeToOptimizeImports(@NotNull PsiFile file) {
833     if (!CodeInsightWorkspaceSettings.getInstance(file.getProject()).optimizeImportsOnTheFly) return false;
834
835     DaemonCodeAnalyzerEx codeAnalyzer = DaemonCodeAnalyzerEx.getInstanceEx(file.getProject());
836     // dont optimize out imports in JSP since it can be included in other JSP
837     if (!codeAnalyzer.isHighlightingAvailable(file) || !(file instanceof PsiJavaFile) || file instanceof ServerPageFile) return false;
838
839     if (!codeAnalyzer.isErrorAnalyzingFinished(file)) return false;
840     boolean errors = containsErrorsPreventingOptimize(file);
841
842     return !errors && DaemonListeners.canChangeFileSilently(file);
843   }
844
845   private static boolean containsErrorsPreventingOptimize(@NotNull PsiFile file) {
846     Document document = PsiDocumentManager.getInstance(file.getProject()).getDocument(file);
847     if (document == null) return true;
848     // ignore unresolved imports errors
849     PsiImportList importList = ((PsiJavaFile)file).getImportList();
850     final TextRange importsRange = importList == null ? TextRange.EMPTY_RANGE : importList.getTextRange();
851     //noinspection UnnecessaryLocalVariable
852     boolean hasErrorsExceptUnresolvedImports = !DaemonCodeAnalyzerEx
853       .processHighlights(document, file.getProject(), HighlightSeverity.ERROR, 0, document.getTextLength(), error -> {
854         if (error.type instanceof LocalInspectionsPass.InspectionHighlightInfoType) return true;
855         int infoStart = error.getActualStartOffset();
856         int infoEnd = error.getActualEndOffset();
857
858         return importsRange.containsRange(infoStart, infoEnd) && error.type.equals(HighlightInfoType.WRONG_REF);
859       });
860
861     return hasErrorsExceptUnresolvedImports;
862   }
863
864   @NotNull
865   @Override
866   public IntentionAction createCollectionToArrayFix(@NotNull PsiExpression collectionExpression,
867                                                     @NotNull PsiExpression expressionToReplace,
868                                                     @NotNull PsiArrayType arrayType) {
869     return new ConvertCollectionToArrayFix(collectionExpression, expressionToReplace, arrayType);
870   }
871
872   @NotNull
873   @Override
874   public IntentionAction createInsertMethodCallFix(@NotNull PsiMethodCallExpression call, @NotNull PsiMethod method) {
875     return new InsertMethodCallFix(call, method);
876   }
877
878   @NotNull
879   @Override
880   public LocalQuickFixAndIntentionActionOnPsiElement createAccessStaticViaInstanceFix(@NotNull PsiReferenceExpression methodRef,
881                                                                                       @NotNull JavaResolveResult result) {
882     return new AccessStaticViaInstanceFix(methodRef, result, true);
883   }
884
885   @NotNull
886   @Override
887   public IntentionAction createWrapWithAdapterFix(@Nullable PsiType type, @NotNull PsiExpression expression) {
888     return new WrapWithAdapterMethodCallFix(type, expression);
889   }
890
891   @NotNull
892   @Override
893   public IntentionAction createDeleteSideEffectAwareFix(@NotNull PsiExpressionStatement statement) {
894     return new DeleteSideEffectsAwareFix(statement, statement.getExpression());
895   }
896
897   @Nullable
898   @Override
899   public IntentionAction createCreateClassInPackageInModuleFix(@NotNull Module module, @Nullable String packageName) {
900     return CreateClassInPackageInModuleFix.createFix(module, packageName);
901   }
902
903   @NotNull
904   @Override
905   public IntentionAction createPushDownMethodFix() {
906     return new RunRefactoringAction(new JavaPushDownHandler(), "Push method down...") {
907       @NotNull
908       @Override
909       public Priority getPriority() {
910         return Priority.NORMAL;
911       }
912     };
913   }
914
915   @NotNull
916   @Override
917   public IntentionAction createSameErasureButDifferentMethodsFix(@NotNull PsiMethod method, @NotNull PsiMethod superMethod) {
918     return new SameErasureButDifferentMethodsFix(method, superMethod);
919   }
920   
921   @Override
922   public IntentionAction createAddMissingEnumBranchesFix(@NotNull PsiSwitchBlock switchBlock, @NotNull Set<String> missingCases) {
923     return new CreateMissingSwitchBranchesFix(switchBlock, missingCases);
924   } 
925   
926   @Override
927   public IntentionAction createAddSwitchDefaultFix(@NotNull PsiSwitchBlock switchBlock, String message) {
928     return new CreateDefaultBranchFix(switchBlock, message);
929   } 
930 }