diff --git a/java/compiler/impl/src/com/intellij/compiler/impl/javaCompiler/BackendCompilerWrapper.java b/java/compiler/impl/src/com/intellij/compiler/impl/javaCompiler/BackendCompilerWrapper.java index cb32e9ed21a8..3a324d87aa74 100644 --- a/java/compiler/impl/src/com/intellij/compiler/impl/javaCompiler/BackendCompilerWrapper.java +++ b/java/compiler/impl/src/com/intellij/compiler/impl/javaCompiler/BackendCompilerWrapper.java @@ -22,6 +22,7 @@ package com.intellij.compiler.impl.javaCompiler; import com.intellij.codeInsight.AnnotationUtil; +import com.intellij.codeInsight.NullableNotNullManager; import com.intellij.compiler.*; import com.intellij.compiler.classParsing.AnnotationConstantValue; import com.intellij.compiler.classParsing.MethodInfo; @@ -827,7 +828,7 @@ public class BackendCompilerWrapper { FileObject path = myPaths.take(); if (path == myStopThreadToken) break; - processPath(path); + processPath(path, myProject); } } catch (InterruptedException e) { @@ -852,7 +853,7 @@ public class BackendCompilerWrapper { myPaths.offer(myStopThreadToken); } - private void processPath(FileObject fileObject) throws CacheCorruptedException { + private void processPath(FileObject fileObject, Project project) throws CacheCorruptedException { File file = fileObject.getFile(); final String path = file.getPath(); try { @@ -866,7 +867,7 @@ public class BackendCompilerWrapper { final String qName = dependencyCache.resolve(newClassQName); String relativePathToSource = "/" + MakeUtil.createRelativePathToSource(qName, sourceFileName); putName(sourceFileName, newClassQName, relativePathToSource, path); - boolean haveToInstrument = myAddNotNullAssertions && hasNotNullAnnotations(newClassesCache, dependencyCache.getSymbolTable(), newClassQName); + boolean haveToInstrument = myAddNotNullAssertions && hasNotNullAnnotations(newClassesCache, dependencyCache.getSymbolTable(), newClassQName, project); if (haveToInstrument) { try { @@ -913,17 +914,19 @@ public class BackendCompilerWrapper { } } - private static boolean hasNotNullAnnotations(final Cache cache, final SymbolTable symbolTable, final int className) throws CacheCorruptedException { + private static boolean hasNotNullAnnotations(final Cache cache, final SymbolTable symbolTable, final int className, Project project) throws CacheCorruptedException { + final NullableNotNullManager manager = NullableNotNullManager.getInstance(project); + final List notNulls = manager.getNotNulls(); for (MethodInfo methodId : cache.getMethods(className)) { for (AnnotationConstantValue annotation : methodId.getRuntimeInvisibleAnnotations()) { - if (AnnotationUtil.NOT_NULL.equals(symbolTable.getSymbol(annotation.getAnnotationQName()))) { + if (notNulls.contains(symbolTable.getSymbol(annotation.getAnnotationQName()))) { return true; } } final AnnotationConstantValue[][] paramAnnotations = methodId.getRuntimeInvisibleParameterAnnotations(); for (AnnotationConstantValue[] _singleParamAnnotations : paramAnnotations) { for (AnnotationConstantValue annotation : _singleParamAnnotations) { - if (AnnotationUtil.NOT_NULL.equals(symbolTable.getSymbol(annotation.getAnnotationQName()))) { + if (notNulls.contains(symbolTable.getSymbol(annotation.getAnnotationQName()))) { return true; } } diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/GenerateConstructorHandler.java b/java/java-impl/src/com/intellij/codeInsight/generation/GenerateConstructorHandler.java index 4ca1412a9e6f..0419d0b848c5 100644 --- a/java/java-impl/src/com/intellij/codeInsight/generation/GenerateConstructorHandler.java +++ b/java/java-impl/src/com/intellij/codeInsight/generation/GenerateConstructorHandler.java @@ -18,6 +18,7 @@ package com.intellij.codeInsight.generation; import com.intellij.CommonBundle; import com.intellij.codeInsight.AnnotationUtil; import com.intellij.codeInsight.CodeInsightBundle; +import com.intellij.codeInsight.NullableNotNullManager; import com.intellij.codeInsight.daemon.ImplicitUsageProvider; import com.intellij.ide.util.MemberChooser; import com.intellij.openapi.diagnostic.Logger; @@ -228,9 +229,9 @@ public class GenerateConstructorHandler extends GenerateMembersHandlerBase { parmName = javaStyle.suggestUniqueVariableName(parmName, constructor, true); PsiParameter parm = factory.createParameter(parmName, field.getType()); - - if (AnnotationUtil.isAnnotated(field, AnnotationUtil.NOT_NULL, false)) { - final PsiAnnotation annotation = factory.createAnnotationFromText("@" + AnnotationUtil.NOT_NULL, field); + final NullableNotNullManager nullableManager = NullableNotNullManager.getInstance(field.getProject()); + if (nullableManager.isNotNull(field, false)) { + final PsiAnnotation annotation = factory.createAnnotationFromText("@" + nullableManager.getDefaultNotNull(), field); parm.getModifierList().addAfter(annotation, null); } diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementUtil.java b/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementUtil.java index 69315cd44387..dadf5ee5a86e 100644 --- a/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementUtil.java +++ b/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementUtil.java @@ -313,12 +313,13 @@ public class OverrideImplementUtil { } final Module module = ModuleUtil.findModuleForPsiElement(targetClass); final GlobalSearchScope moduleScope = module != null ? GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module) : null; - final JavaPsiFacade facade = JavaPsiFacade.getInstance(targetClass.getProject()); + final Project project = targetClass.getProject(); + final JavaPsiFacade facade = JavaPsiFacade.getInstance(project); for (OverrideImplementsAnnotationsHandler each : Extensions.getExtensions(OverrideImplementsAnnotationsHandler.EP_NAME)) { - for (String annotation : each.getAnnotations()) { + for (String annotation : each.getAnnotations(project)) { if (moduleScope != null && facade.findClass(annotation, moduleScope) == null) continue; if (AnnotationUtil.isAnnotated(overridden, annotation, false)) { - annotate(method, annotation, each.annotationsToRemove(annotation)); + annotate(method, annotation, each.annotationsToRemove(project, annotation)); } } } diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementsAnnotationsHandler.java b/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementsAnnotationsHandler.java index a35618b96288..b69f53b762ea 100644 --- a/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementsAnnotationsHandler.java +++ b/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementsAnnotationsHandler.java @@ -21,12 +21,13 @@ package com.intellij.codeInsight.generation; import com.intellij.openapi.extensions.ExtensionPointName; +import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; public interface OverrideImplementsAnnotationsHandler { ExtensionPointName EP_NAME = ExtensionPointName.create("com.intellij.overrideImplementsAnnotationsHandler"); - String[] getAnnotations(); + String[] getAnnotations(Project project); @NotNull - String [] annotationsToRemove(@NotNull String fqName); + String [] annotationsToRemove(Project project, @NotNull String fqName); } \ No newline at end of file diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementsAnnotationsHandlerImpl.java b/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementsAnnotationsHandlerImpl.java index 0d4561f7dfb5..5f707acd6857 100644 --- a/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementsAnnotationsHandlerImpl.java +++ b/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementsAnnotationsHandlerImpl.java @@ -21,23 +21,33 @@ package com.intellij.codeInsight.generation; import com.intellij.codeInsight.AnnotationUtil; +import com.intellij.codeInsight.NullableNotNullManager; +import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Comparing; +import com.intellij.openapi.util.JDOMExternalizableStringList; import com.intellij.util.ArrayUtil; import org.jetbrains.annotations.NotNull; +import java.util.ArrayList; +import java.util.Collection; + public class OverrideImplementsAnnotationsHandlerImpl implements OverrideImplementsAnnotationsHandler { - public String[] getAnnotations() { - return new String[]{AnnotationUtil.NOT_NULL,AnnotationUtil.NLS}; + public String[] getAnnotations(Project project) { + final NullableNotNullManager manager = NullableNotNullManager.getInstance(project); + final Collection anns = new ArrayList(manager.getNotNulls()); + anns.add(AnnotationUtil.NLS); + return ArrayUtil.toStringArray(anns); } @NotNull - public String[] annotationsToRemove(@NotNull final String fqName) { - if (Comparing.strEqual(fqName, AnnotationUtil.NOT_NULL)) { - return new String[]{AnnotationUtil.NULLABLE}; + public String[] annotationsToRemove(Project project, @NotNull final String fqName) { + final NullableNotNullManager manager = NullableNotNullManager.getInstance(project); + if (manager.getNotNulls().contains(fqName)) { + return ArrayUtil.toStringArray(manager.getNullables()); } if (Comparing.strEqual(fqName, AnnotationUtil.NLS)){ return new String[]{AnnotationUtil.NON_NLS}; } return ArrayUtil.EMPTY_STRING_ARRAY; } -} \ No newline at end of file +} diff --git a/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddNotNullAnnotationFix.java b/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddNotNullAnnotationFix.java index 3ef33e177c8b..86a23fcce8f1 100644 --- a/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddNotNullAnnotationFix.java +++ b/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddNotNullAnnotationFix.java @@ -23,13 +23,25 @@ package com.intellij.codeInsight.intention.impl; import com.intellij.codeInsight.AnnotationUtil; +import com.intellij.codeInsight.NullableNotNullManager; import com.intellij.psi.PsiModifierListOwner; +import com.intellij.util.ArrayUtil; + +import java.util.List; public class AddNotNullAnnotationFix extends AddNullableNotNullAnnotationFix { + @Deprecated public AddNotNullAnnotationFix() { super(AnnotationUtil.NOT_NULL, AnnotationUtil.NULLABLE); } public AddNotNullAnnotationFix(PsiModifierListOwner owner) { - super(AnnotationUtil.NOT_NULL, owner, AnnotationUtil.NULLABLE); + super(NullableNotNullManager.getInstance(owner.getProject()).getDefaultNotNull(), + owner, + getNullables(owner)); + } + + private static String[] getNullables(PsiModifierListOwner owner) { + final List nullables = NullableNotNullManager.getInstance(owner.getProject()).getNullables(); + return ArrayUtil.toStringArray(nullables); } } \ No newline at end of file diff --git a/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddNullableAnnotationFix.java b/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddNullableAnnotationFix.java index af1d066db68f..cc995bf84509 100644 --- a/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddNullableAnnotationFix.java +++ b/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddNullableAnnotationFix.java @@ -23,9 +23,26 @@ package com.intellij.codeInsight.intention.impl; import com.intellij.codeInsight.AnnotationUtil; +import com.intellij.codeInsight.NullableNotNullManager; +import com.intellij.psi.PsiModifierListOwner; +import com.intellij.util.ArrayUtil; + +import java.util.List; public class AddNullableAnnotationFix extends AddNullableNotNullAnnotationFix { + @Deprecated public AddNullableAnnotationFix() { super(AnnotationUtil.NULLABLE, AnnotationUtil.NOT_NULL); } -} \ No newline at end of file + + public AddNullableAnnotationFix(PsiModifierListOwner owner) { + super(NullableNotNullManager.getInstance(owner.getProject()).getDefaultNullable(), + owner, + getNotNulls(owner)); + } + + private static String[] getNotNulls(PsiModifierListOwner owner) { + final List notnulls = NullableNotNullManager.getInstance(owner.getProject()).getNotNulls(); + return ArrayUtil.toStringArray(notnulls); + } +} diff --git a/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddNullableNotNullAnnotationFix.java b/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddNullableNotNullAnnotationFix.java index d3a7edf01d3b..30428a04233d 100644 --- a/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddNullableNotNullAnnotationFix.java +++ b/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddNullableNotNullAnnotationFix.java @@ -30,11 +30,11 @@ import com.intellij.psi.*; import org.jetbrains.annotations.NotNull; public class AddNullableNotNullAnnotationFix extends AddAnnotationFix { - public AddNullableNotNullAnnotationFix(final String annotation, final String annotationToRemove) { + public AddNullableNotNullAnnotationFix(final String annotation, final String... annotationToRemove) { super(annotation, annotationToRemove); } - public AddNullableNotNullAnnotationFix(final String fqn, final PsiModifierListOwner owner, final String annotationToRemove) { + public AddNullableNotNullAnnotationFix(final String fqn, final PsiModifierListOwner owner, final String... annotationToRemove) { super(fqn, owner, annotationToRemove); } @@ -54,4 +54,4 @@ public class AddNullableNotNullAnnotationFix extends AddAnnotationFix { } return true; } -} \ No newline at end of file +} diff --git a/java/java-impl/src/com/intellij/codeInsight/intention/impl/CreateFieldFromParameterAction.java b/java/java-impl/src/com/intellij/codeInsight/intention/impl/CreateFieldFromParameterAction.java index 4efd07e3333d..59058a94a542 100644 --- a/java/java-impl/src/com/intellij/codeInsight/intention/impl/CreateFieldFromParameterAction.java +++ b/java/java-impl/src/com/intellij/codeInsight/intention/impl/CreateFieldFromParameterAction.java @@ -18,6 +18,7 @@ package com.intellij.codeInsight.intention.impl; import com.intellij.codeInsight.AnnotationUtil; import com.intellij.codeInsight.CodeInsightBundle; import com.intellij.codeInsight.CodeInsightUtilBase; +import com.intellij.codeInsight.NullableNotNullManager; import com.intellij.codeInsight.intention.IntentionAction; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.diagnostic.Logger; @@ -213,8 +214,9 @@ public class CreateFieldFromParameterAction implements IntentionAction { modifierList.setModifierProperty(PsiModifier.STATIC, isMethodStatic); modifierList.setModifierProperty(PsiModifier.FINAL, isFinal); - if (AnnotationUtil.isAnnotated(myParameter, AnnotationUtil.NULLABLE, false)) { - modifierList.addAfter(factory.createAnnotationFromText("@" + AnnotationUtil.NULLABLE, field), null); + final NullableNotNullManager manager = NullableNotNullManager.getInstance(project); + if (manager.isNullable(myParameter, false)) { + modifierList.addAfter(factory.createAnnotationFromText("@" + manager.getDefaultNullable(), field), null); } PsiCodeBlock methodBody = method.getBody(); diff --git a/java/java-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInspection.java b/java/java-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInspection.java index 7afc06fe276c..802cf2c61d54 100644 --- a/java/java-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInspection.java +++ b/java/java-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInspection.java @@ -26,17 +26,24 @@ package com.intellij.codeInspection.dataFlow; import com.intellij.codeInsight.AnnotationUtil; import com.intellij.codeInsight.CodeInsightUtilBase; +import com.intellij.codeInsight.NullableNotNullDialog; +import com.intellij.codeInsight.NullableNotNullManager; import com.intellij.codeInsight.daemon.GroupNames; import com.intellij.codeInsight.daemon.impl.quickfix.SimplifyBooleanExpressionFix; import com.intellij.codeInspection.*; import com.intellij.codeInspection.dataFlow.instructions.*; import com.intellij.codeInspection.ex.BaseLocalInspectionTool; +import com.intellij.codeInspection.ex.EntryPointsManagerImpl; +import com.intellij.ide.DataManager; +import com.intellij.openapi.actionSystem.PlatformDataKeys; import com.intellij.openapi.application.ApplicationNamesInfo; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.project.Project; +import com.intellij.openapi.project.ProjectManager; import com.intellij.openapi.util.Pair; import com.intellij.psi.*; import com.intellij.psi.util.PsiUtil; +import com.intellij.util.ArrayUtil; import com.intellij.util.IncorrectOperationException; import com.intellij.util.SmartList; import org.jetbrains.annotations.NonNls; @@ -47,6 +54,8 @@ import javax.swing.*; import javax.swing.event.ChangeEvent; import javax.swing.event.ChangeListener; import java.awt.*; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; import java.util.*; import java.util.List; @@ -266,7 +275,8 @@ public class DataFlowInspection extends BaseLocalInspectionTool { final String text = isNullLiteralExpression(expr) ? InspectionsBundle.message("dataflow.message.return.null.from.notnullable") : InspectionsBundle.message("dataflow.message.return.nullable.from.notnullable"); - holder.registerProblem(expr, text, new AnnotateMethodFix(AnnotationUtil.NULLABLE, AnnotationUtil.NOT_NULL)); + final NullableNotNullManager manager = NullableNotNullManager.getInstance(expr.getProject()); + holder.registerProblem(expr, text, new AnnotateMethodFix(manager.getDefaultNullable(), ArrayUtil.toStringArray(manager.getNotNulls()))); } } @@ -416,10 +426,27 @@ public class DataFlowInspection extends BaseLocalInspectionTool { } }); - gc.insets = new Insets(0, 0, 15, 0); + gc.insets = new Insets(0, 0, 0, 0); gc.gridy = 0; add(mySuggestNullables, gc); + final JButton configureAnnotations = new JButton("Configure annotations"); + configureAnnotations.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent e) { + Project project = PlatformDataKeys.PROJECT.getData(DataManager.getInstance().getDataContext(OptionsPanel.this)); + if (project == null) project = ProjectManager.getInstance().getDefaultProject(); + final NullableNotNullDialog dialog = new NullableNotNullDialog(project); + dialog.show(); + } + }); + gc.gridy++; + gc.fill = GridBagConstraints.NONE; + gc.insets.left = 20; + gc.insets.bottom = 15; + add(configureAnnotations, gc); + + gc.insets.left = 0; gc.gridy++; add(myDontReportTrueAsserts, gc); } diff --git a/java/java-impl/src/com/intellij/codeInspection/dataFlow/StandardInstructionVisitor.java b/java/java-impl/src/com/intellij/codeInspection/dataFlow/StandardInstructionVisitor.java index 687f7fb36391..96ac6d0ba52e 100644 --- a/java/java-impl/src/com/intellij/codeInspection/dataFlow/StandardInstructionVisitor.java +++ b/java/java-impl/src/com/intellij/codeInspection/dataFlow/StandardInstructionVisitor.java @@ -16,6 +16,7 @@ package com.intellij.codeInspection.dataFlow; import com.intellij.codeInsight.AnnotationUtil; +import com.intellij.codeInsight.NullableNotNullManager; import com.intellij.codeInspection.dataFlow.instructions.*; import com.intellij.codeInspection.dataFlow.value.*; import com.intellij.psi.*; @@ -45,7 +46,7 @@ public class StandardInstructionVisitor extends InstructionVisitor { final PsiParameter[] params = callee.getParameterList().getParameters(); boolean[] result = new boolean[params.length]; for (int i = 0; i < params.length; i++) { - result[i] = AnnotationUtil.isAnnotated(params[i], AnnotationUtil.NOT_NULL, false); + result[i] = NullableNotNullManager.getInstance(params[i].getProject()).isNotNull(params[i], false); } return result; } @@ -85,7 +86,8 @@ public class StandardInstructionVisitor extends InstructionVisitor { if (dfaDest instanceof DfaVariableValue) { DfaVariableValue var = (DfaVariableValue) dfaDest; final PsiVariable psiVariable = var.getPsiVariable(); - if (AnnotationUtil.isAnnotated(psiVariable, AnnotationUtil.NOT_NULL, false)) { + final NullableNotNullManager nullableManager = NullableNotNullManager.getInstance(psiVariable.getProject()); + if (nullableManager.isNotNull(psiVariable, false)) { if (!memState.applyNotNull(dfaSource)) { onAssigningToNotNullableVariable(instruction, runner); } diff --git a/java/java-impl/src/com/intellij/codeInspection/inferNullity/InferNullityAnnotationsAction.java b/java/java-impl/src/com/intellij/codeInspection/inferNullity/InferNullityAnnotationsAction.java index 16a7c4adcf1d..0ff944736e82 100644 --- a/java/java-impl/src/com/intellij/codeInspection/inferNullity/InferNullityAnnotationsAction.java +++ b/java/java-impl/src/com/intellij/codeInspection/inferNullity/InferNullityAnnotationsAction.java @@ -19,6 +19,7 @@ import com.intellij.analysis.AnalysisScope; import com.intellij.analysis.BaseAnalysisAction; import com.intellij.analysis.BaseAnalysisActionDialog; import com.intellij.codeInsight.AnnotationUtil; +import com.intellij.codeInsight.NullableNotNullManager; import com.intellij.codeInsight.daemon.QuickFixBundle; import com.intellij.codeInsight.daemon.impl.quickfix.LocateLibraryDialog; import com.intellij.codeInsight.daemon.impl.quickfix.OrderEntryFix; @@ -87,7 +88,7 @@ public class InferNullityAnnotationsAction extends BaseAnalysisAction { if (module != null && !processed.contains(module)) { processed.add(module); if (JavaPsiFacade.getInstance(project) - .findClass(AnnotationUtil.NULLABLE, GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module)) == null) { + .findClass(NullableNotNullManager.getInstance(project).getDefaultNullable(), GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module)) == null) { modulesWithoutAnnotations.add(module); } if (PsiUtil.getLanguageLevel(file).compareTo(LanguageLevel.JDK_1_5) < 0) { @@ -103,8 +104,9 @@ public class InferNullityAnnotationsAction extends BaseAnalysisAction { return; } if (!modulesWithoutAnnotations.isEmpty()) { - if (Messages.showOkCancelDialog(project, "Infer Nullity Annotations requires that the JetBrains nullity annotations" + - " be available to your project.\n\nYou will need to add annotations.jar (available in your IDEA distribution) as a library. " + + if (Messages.showOkCancelDialog(project, "Infer Nullity Annotations requires that the nullity annotations" + + " be available to your project.\n\nYou will need to add annotations.jar as a library. " + + "It is possible to configure custom jar in e.g. Constant Conditions & Exceptions inspection or use JetBrains annotations available in installation. " + " The IDEA nullity annotations are freely usable and redistributable under the Apache 2.0 license. Would you like to do it now?", INFER_NULLITY_ANNOTATIONS, Messages.getErrorIcon()) == DialogWrapper.OK_EXIT_CODE) { ApplicationManager.getApplication().invokeLater(new Runnable() { diff --git a/java/java-impl/src/com/intellij/codeInspection/inferNullity/NullityInferrer.java b/java/java-impl/src/com/intellij/codeInspection/inferNullity/NullityInferrer.java index 93415f77079f..422378077c6d 100644 --- a/java/java-impl/src/com/intellij/codeInspection/inferNullity/NullityInferrer.java +++ b/java/java-impl/src/com/intellij/codeInspection/inferNullity/NullityInferrer.java @@ -16,6 +16,7 @@ package com.intellij.codeInspection.inferNullity; import com.intellij.codeInsight.AnnotationUtil; +import com.intellij.codeInsight.NullableNotNullManager; import com.intellij.codeInsight.intention.AddAnnotationFix; import com.intellij.notification.Notification; import com.intellij.notification.NotificationDisplayType; @@ -148,11 +149,12 @@ public class NullityInferrer { } public void apply(final Project project) { + final NullableNotNullManager manager = NullableNotNullManager.getInstance(project); for (SmartPsiElementPointer pointer : myNullableSet) { final PsiModifierListOwner element = pointer.getElement(); if (element != null) { if (shouldIgnore(element)) continue; - new AddAnnotationFix(AnnotationUtil.NULLABLE, element, AnnotationUtil.NOT_NULL).invoke(project, null, element.getContainingFile()); + new AddAnnotationFix(manager.getDefaultNullable(), element, manager.getDefaultNotNull()).invoke(project, null, element.getContainingFile()); } } @@ -160,7 +162,8 @@ public class NullityInferrer { final PsiModifierListOwner element = pointer.getElement(); if (element != null) { if (shouldIgnore(element)) continue; - new AddAnnotationFix(AnnotationUtil.NOT_NULL, element, AnnotationUtil.NULLABLE).invoke(project, null, element.getContainingFile()); + new AddAnnotationFix(manager.getDefaultNotNull(), element, manager.getDefaultNullable()).invoke(project, null, + element.getContainingFile()); } } @@ -425,8 +428,8 @@ public class NullityInferrer { return; } } - if (!AnnotationUtil.isAnnotated(method, AnnotationUtil.NOT_NULL, false) && - AnnotationUtil.isAnnotated(method, AnnotationUtil.NOT_NULL, true)) { + final NullableNotNullManager manager = NullableNotNullManager.getInstance(method.getProject()); + if (!manager.isNotNull(method, false) && manager.isNotNull(method, true)) { registerNotNullAnnotation(method); return; } diff --git a/java/java-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspection.java b/java/java-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspection.java index 3d2fa931a3a1..12e367d0e9c9 100644 --- a/java/java-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspection.java +++ b/java/java-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspection.java @@ -16,12 +16,14 @@ package com.intellij.codeInspection.nullable; import com.intellij.codeInsight.AnnotationUtil; +import com.intellij.codeInsight.NullableNotNullManager; import com.intellij.codeInsight.daemon.GroupNames; import com.intellij.codeInsight.intention.AddAnnotationFix; import com.intellij.codeInsight.intention.impl.AddNotNullAnnotationFix; import com.intellij.codeInspection.*; import com.intellij.codeInspection.ex.BaseLocalInspectionTool; import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; import com.intellij.psi.codeStyle.JavaCodeStyleManager; import com.intellij.psi.codeStyle.VariableKind; @@ -30,6 +32,7 @@ import com.intellij.psi.search.LocalSearchScope; import com.intellij.psi.search.searches.OverridingMethodsSearch; import com.intellij.psi.search.searches.ReferencesSearch; import com.intellij.psi.util.*; +import com.intellij.util.ArrayUtil; import com.intellij.util.Processor; import com.intellij.util.Query; import org.jetbrains.annotations.NotNull; @@ -48,18 +51,6 @@ public class NullableStuffInspection extends BaseLocalInspectionTool { @SuppressWarnings({"WeakerAccess"}) public boolean REPORT_NOT_ANNOTATED_GETTER = true; @SuppressWarnings({"WeakerAccess"}) public boolean REPORT_NOT_ANNOTATED_SETTER_PARAMETER = true; @SuppressWarnings({"WeakerAccess"}) public boolean REPORT_ANNOTATION_NOT_PROPAGATED_TO_OVERRIDERS = true; - private static final AnnotateMethodFix ANNOTATE_OVERRIDDEN_METHODS_FIX = new AnnotateMethodFix(AnnotationUtil.NOT_NULL, AnnotationUtil.NULLABLE){ - protected boolean annotateOverriddenMethods() { - return true; - } - - @NotNull - public String getName() { - return InspectionsBundle.message("annotate.overridden.methods.as.notnull"); - } - }; - private static final AnnotateOverriddenMethodParameterFix ANNOTATE_OVERRIDDEN_METHODS_PARAMS_FIX = - new AnnotateOverriddenMethodParameterFix(AnnotationUtil.NOT_NULL, AnnotationUtil.NULLABLE); @NotNull public PsiElementVisitor buildVisitor(@NotNull final ProblemsHolder holder, boolean isOnTheFly) { @@ -79,31 +70,34 @@ public class NullableStuffInspection extends BaseLocalInspectionTool { if (TypeConversionUtil.isPrimitiveAndNotNull(type)) { return; } + final NullableNotNullManager manager = NullableNotNullManager.getInstance(field.getProject()); if (annotated.isDeclaredNotNull ^ annotated.isDeclaredNullable) { - final String anno = annotated.isDeclaredNotNull ? AnnotationUtil.NOT_NULL : AnnotationUtil.NULLABLE; - final String annoToRemove = annotated.isDeclaredNotNull ? AnnotationUtil.NULLABLE : AnnotationUtil.NOT_NULL; - final String simpleName = annotated.isDeclaredNotNull ? AnnotationUtil.NOT_NULL_SIMPLE_NAME : AnnotationUtil.NULLABLE_SIMPLE_NAME; + final String anno = annotated.isDeclaredNotNull ? manager.getDefaultNotNull() : manager.getDefaultNullable(); + final List annoToRemove = annotated.isDeclaredNotNull ? manager.getNullables() : manager.getNotNulls(); - final String propName = JavaCodeStyleManager.getInstance(field.getProject()).variableNameToPropertyName(field.getName(), VariableKind.FIELD); + final String propName = JavaCodeStyleManager.getInstance(field.getProject()).variableNameToPropertyName(field.getName(), + VariableKind.FIELD); final boolean isStatic = field.hasModifierProperty(PsiModifier.STATIC); final PsiMethod getter = PropertyUtil.findPropertyGetter(field.getContainingClass(), propName, isStatic, false); + final String nullableSimpleName = StringUtil.getShortName(manager.getDefaultNullable()); + final String notNullSimpleName = StringUtil.getShortName(manager.getDefaultNotNull()); if (getter != null) { if (REPORT_NOT_ANNOTATED_GETTER) { - if (!AnnotationUtil.isAnnotated(getter, AnnotationUtil.ALL_ANNOTATIONS) && + if (!AnnotationUtil.isAnnotated(getter, manager.getAllAnnotations()) && !TypeConversionUtil.isPrimitiveAndNotNull(getter.getReturnType())) { holder.registerProblem(getter.getNameIdentifier(), InspectionsBundle - .message("inspection.nullable.problems.annotated.field.getter.not.annotated", simpleName), - ProblemHighlightType.GENERIC_ERROR_OR_WARNING, new AnnotateMethodFix(anno, annoToRemove)); + .message("inspection.nullable.problems.annotated.field.getter.not.annotated", StringUtil.getShortName(anno)), + ProblemHighlightType.GENERIC_ERROR_OR_WARNING, new AnnotateMethodFix(anno, ArrayUtil.toStringArray(annoToRemove))); } } - if (annotated.isDeclaredNotNull && AnnotationUtil.isAnnotated(getter, AnnotationUtil.NULLABLE, false)) { + if (annotated.isDeclaredNotNull && manager.isNullable(getter, false)) { holder.registerProblem(getter.getNameIdentifier(), InspectionsBundle.message( - "inspection.nullable.problems.annotated.field.getter.conflict", simpleName, AnnotationUtil.NULLABLE_SIMPLE_NAME), - ProblemHighlightType.GENERIC_ERROR_OR_WARNING, new AnnotateMethodFix(anno, annoToRemove)); - } else if (annotated.isDeclaredNullable && AnnotationUtil.isAnnotated(getter, AnnotationUtil.NOT_NULL, false)) { + "inspection.nullable.problems.annotated.field.getter.conflict", StringUtil.getShortName(anno), nullableSimpleName), + ProblemHighlightType.GENERIC_ERROR_OR_WARNING, new AnnotateMethodFix(anno, ArrayUtil.toStringArray(annoToRemove))); + } else if (annotated.isDeclaredNullable && manager.isNotNull(getter, false)) { holder.registerProblem(getter.getNameIdentifier(), InspectionsBundle.message( - "inspection.nullable.problems.annotated.field.getter.conflict", simpleName, AnnotationUtil.NOT_NULL_SIMPLE_NAME), - ProblemHighlightType.GENERIC_ERROR_OR_WARNING, new AnnotateMethodFix(anno, annoToRemove)); + "inspection.nullable.problems.annotated.field.getter.conflict", StringUtil.getShortName(anno), notNullSimpleName), + ProblemHighlightType.GENERIC_ERROR_OR_WARNING, new AnnotateMethodFix(anno, ArrayUtil.toStringArray(annoToRemove))); } } @@ -113,22 +107,24 @@ public class NullableStuffInspection extends BaseLocalInspectionTool { final PsiParameter[] parameters = setter.getParameterList().getParameters(); assert parameters.length == 1; final PsiParameter parameter = parameters[0]; - if (REPORT_NOT_ANNOTATED_SETTER_PARAMETER && !AnnotationUtil.isAnnotated(parameter, AnnotationUtil.ALL_ANNOTATIONS) && !TypeConversionUtil.isPrimitiveAndNotNull(parameter.getType())) { + if (REPORT_NOT_ANNOTATED_SETTER_PARAMETER && !AnnotationUtil.isAnnotated(parameter, manager.getAllAnnotations()) && !TypeConversionUtil.isPrimitiveAndNotNull(parameter.getType())) { holder.registerProblem(parameter.getNameIdentifier(), - InspectionsBundle.message("inspection.nullable.problems.annotated.field.setter.parameter.not.annotated", simpleName), + InspectionsBundle.message("inspection.nullable.problems.annotated.field.setter.parameter.not.annotated", + StringUtil.getShortName(anno)), ProblemHighlightType.GENERIC_ERROR_OR_WARNING, - new AddAnnotationFix(anno, parameter, annoToRemove)); + new AddAnnotationFix(anno, parameter, ArrayUtil.toStringArray(annoToRemove))); } - if (annotated.isDeclaredNotNull && AnnotationUtil.isAnnotated(parameter, AnnotationUtil.NULLABLE, false)) { + if (annotated.isDeclaredNotNull && manager.isNullable(parameter, false)) { holder.registerProblem(parameter.getNameIdentifier(), InspectionsBundle.message( - "inspection.nullable.problems.annotated.field.setter.parameter.conflict", simpleName, AnnotationUtil.NULLABLE_SIMPLE_NAME), + "inspection.nullable.problems.annotated.field.setter.parameter.conflict", + StringUtil.getShortName(anno), nullableSimpleName), ProblemHighlightType.GENERIC_ERROR_OR_WARNING, - new AddAnnotationFix(anno, parameter, annoToRemove)); - } else if (annotated.isDeclaredNullable && AnnotationUtil.isAnnotated(parameter, AnnotationUtil.NOT_NULL, false)) { + new AddAnnotationFix(anno, parameter, ArrayUtil.toStringArray(annoToRemove))); + } else if (annotated.isDeclaredNullable && manager.isNotNull(parameter, false)) { holder.registerProblem(parameter.getNameIdentifier(), InspectionsBundle.message( - "inspection.nullable.problems.annotated.field.setter.parameter.conflict", simpleName, AnnotationUtil.NOT_NULL_SIMPLE_NAME), + "inspection.nullable.problems.annotated.field.setter.parameter.conflict", StringUtil.getShortName(anno), notNullSimpleName), ProblemHighlightType.GENERIC_ERROR_OR_WARNING, - new AddAnnotationFix(anno, parameter, annoToRemove)); + new AddAnnotationFix(anno, parameter, ArrayUtil.toStringArray(annoToRemove))); } if (containingClass == null) { return; @@ -164,22 +160,25 @@ public class NullableStuffInspection extends BaseLocalInspectionTool { if (!method.equals(parameter.getDeclarationScope())) { return true; } - if (REPORT_NOT_ANNOTATED_SETTER_PARAMETER && !AnnotationUtil.isAnnotated(parameter, AnnotationUtil.ALL_ANNOTATIONS)) { + if (REPORT_NOT_ANNOTATED_SETTER_PARAMETER && !AnnotationUtil.isAnnotated(parameter, manager.getAllAnnotations())) { holder.registerProblem(parameter.getNameIdentifier(), InspectionsBundle - .message("inspection.nullable.problems.annotated.field.constructor.parameter.not.annotated", simpleName), - ProblemHighlightType.GENERIC_ERROR_OR_WARNING, new AddAnnotationFix(anno, parameter, annoToRemove)); + .message("inspection.nullable.problems.annotated.field.constructor.parameter.not.annotated", + StringUtil.getShortName(anno)), + ProblemHighlightType.GENERIC_ERROR_OR_WARNING, new AddAnnotationFix(anno, parameter, ArrayUtil.toStringArray(annoToRemove))); return true; } - if (annotated.isDeclaredNotNull && AnnotationUtil.isAnnotated(parameter, AnnotationUtil.NULLABLE, false)) { + if (annotated.isDeclaredNotNull && manager.isNullable(parameter, false)) { holder.registerProblem(parameter.getNameIdentifier(), InspectionsBundle.message( - "inspection.nullable.problems.annotated.field.constructor.parameter.conflict", simpleName, AnnotationUtil.NULLABLE_SIMPLE_NAME), + "inspection.nullable.problems.annotated.field.constructor.parameter.conflict", StringUtil.getShortName(anno), + nullableSimpleName), ProblemHighlightType.GENERIC_ERROR_OR_WARNING, - new AddAnnotationFix(anno, parameter, annoToRemove)); - } else if (annotated.isDeclaredNullable && AnnotationUtil.isAnnotated(parameter, AnnotationUtil.NOT_NULL, false)) { + new AddAnnotationFix(anno, parameter, ArrayUtil.toStringArray(annoToRemove))); + } else if (annotated.isDeclaredNullable && manager.isNotNull(parameter, false)) { holder.registerProblem(parameter.getNameIdentifier(), InspectionsBundle.message( - "inspection.nullable.problems.annotated.field.constructor.parameter.conflict", simpleName, AnnotationUtil.NOT_NULL_SIMPLE_NAME), + "inspection.nullable.problems.annotated.field.constructor.parameter.conflict", StringUtil.getShortName(anno), + notNullSimpleName), ProblemHighlightType.GENERIC_ERROR_OR_WARNING, - new AddAnnotationFix(anno, parameter, annoToRemove)); + new AddAnnotationFix(anno, parameter, ArrayUtil.toStringArray(annoToRemove))); } return true; } @@ -217,8 +216,9 @@ public class NullableStuffInspection extends BaseLocalInspectionTool { } } private static Annotated check(final PsiModifierListOwner parameter, final ProblemsHolder holder, PsiType type) { - PsiAnnotation isDeclaredNotNull = AnnotationUtil.findAnnotation(parameter, AnnotationUtil.NOT_NULL); - PsiAnnotation isDeclaredNullable = AnnotationUtil.findAnnotation(parameter, AnnotationUtil.NULLABLE); + final NullableNotNullManager manager = NullableNotNullManager.getInstance(parameter.getProject()); + PsiAnnotation isDeclaredNotNull = AnnotationUtil.findAnnotation(parameter, manager.getNotNulls()); + PsiAnnotation isDeclaredNullable = AnnotationUtil.findAnnotation(parameter, manager.getNullables()); if (isDeclaredNullable != null && isDeclaredNotNull != null) { reportNullableNotNullConflict(holder, parameter, isDeclaredNullable, isDeclaredNotNull); } @@ -262,6 +262,7 @@ public class NullableStuffInspection extends BaseLocalInspectionTool { boolean[] reported_notnull_parameter_overrides_nullable = new boolean[parameters.length]; boolean[] reported_not_annotated_parameter_overrides_notnull = new boolean[parameters.length]; + final NullableNotNullManager nullableManager = NullableNotNullManager.getInstance(holder.getProject()); for (MethodSignatureBackedByPsiMethod superMethodSignature : superMethodSignatures) { PsiMethod superMethod = superMethodSignature.getMethod(); if (!reported_nullable_method_overrides_notnull @@ -281,11 +282,12 @@ public class NullableStuffInspection extends BaseLocalInspectionTool { reported_not_annotated_method_overrides_notnull = true; holder.registerProblem(method.getNameIdentifier(), InspectionsBundle.message("inspection.nullable.problems.method.overrides.NotNull"), - ProblemHighlightType.GENERIC_ERROR_OR_WARNING, new AnnotateMethodFix(AnnotationUtil.NOT_NULL, AnnotationUtil.NULLABLE) { - public int annotateBaseMethod(final PsiMethod method, final PsiMethod superMethod, final Project project) { - return NullableStuffInspection.this.annotateBaseMethod(method, superMethod, project); - } - }); + ProblemHighlightType.GENERIC_ERROR_OR_WARNING, new AnnotateMethodFix( + nullableManager.getDefaultNotNull(), ArrayUtil.toStringArray(nullableManager.getNullables())) { + public int annotateBaseMethod(final PsiMethod method, final PsiMethod superMethod, final Project project) { + return NullableStuffInspection.this.annotateBaseMethod(method, superMethod, project); + } + }); } if (REPORT_NOTNULL_PARAMETER_OVERRIDES_NULLABLE || REPORT_NOT_ANNOTATED_PARAMETER_OVERRIDES_NOTNULL) { PsiParameter[] superParameters = superMethod.getParameterList().getParameters(); @@ -296,21 +298,22 @@ public class NullableStuffInspection extends BaseLocalInspectionTool { PsiParameter parameter = parameters[i]; PsiParameter superParameter = superParameters[i]; if (!reported_notnull_parameter_overrides_nullable[i] && REPORT_NOTNULL_PARAMETER_OVERRIDES_NULLABLE && - AnnotationUtil.isAnnotated(parameter, AnnotationUtil.NOT_NULL, false) && - AnnotationUtil.isAnnotated(superParameter, AnnotationUtil.NULLABLE, false)) { + nullableManager.isNotNull(parameter, false) && + nullableManager.isNullable(superParameter, false)) { reported_notnull_parameter_overrides_nullable[i] = true; holder.registerProblem(parameter.getNameIdentifier(), InspectionsBundle.message("inspection.nullable.problems.NotNull.parameter.overrides.Nullable"), ProblemHighlightType.GENERIC_ERROR_OR_WARNING); } - if (!reported_not_annotated_parameter_overrides_notnull[i] && REPORT_NOT_ANNOTATED_PARAMETER_OVERRIDES_NOTNULL && - !AnnotationUtil.isAnnotated(parameter, AnnotationUtil.ALL_ANNOTATIONS) && - AnnotationUtil.isAnnotated(superParameter, AnnotationUtil.NOT_NULL, false)) { - reported_not_annotated_parameter_overrides_notnull[i] = true; - holder.registerProblem(parameter.getNameIdentifier(), - InspectionsBundle.message("inspection.nullable.problems.parameter.overrides.NotNull"), - ProblemHighlightType.GENERIC_ERROR_OR_WARNING, - new AddNotNullAnnotationFix(parameter)); + if (!reported_not_annotated_parameter_overrides_notnull[i] && REPORT_NOT_ANNOTATED_PARAMETER_OVERRIDES_NOTNULL) { + if (!AnnotationUtil.isAnnotated(parameter, nullableManager.getAllAnnotations()) && + nullableManager.isNotNull(superParameter, false)) { + reported_not_annotated_parameter_overrides_notnull[i] = true; + holder.registerProblem(parameter.getNameIdentifier(), + InspectionsBundle.message("inspection.nullable.problems.parameter.overrides.NotNull"), + ProblemHighlightType.GENERIC_ERROR_OR_WARNING, + new AddNotNullAnnotationFix(parameter)); + } } } } @@ -322,7 +325,7 @@ public class NullableStuffInspection extends BaseLocalInspectionTool { boolean hasAnnotatedParameter = false; for (int i = 0; i < parameters.length; i++) { PsiParameter parameter = parameters[i]; - parameterAnnotated[i] = AnnotationUtil.isAnnotated(parameter, AnnotationUtil.NOT_NULL, false); + parameterAnnotated[i] = nullableManager.isNotNull(parameter, false); hasAnnotatedParameter |= parameterAnnotated[i]; } if (hasAnnotatedParameter || annotated.isDeclaredNotNull) { @@ -334,11 +337,20 @@ public class NullableStuffInspection extends BaseLocalInspectionTool { if (!manager.isInProject(overriding)) continue; if (!methodQuickFixSuggested && annotated.isDeclaredNotNull - && !AnnotationUtil.isAnnotated(overriding, AnnotationUtil.NOT_NULL, false)) { + && !nullableManager.isNotNull(overriding, false)) { method.getNameIdentifier(); //load tree - PsiAnnotation annotation = AnnotationUtil.findAnnotation(method, AnnotationUtil.NOT_NULL); + PsiAnnotation annotation = AnnotationUtil.findAnnotation(method, nullableManager.getNotNulls()); holder.registerProblem(annotation, InspectionsBundle.message("nullable.stuff.problems.overridden.methods.are.not.annotated"), - ProblemHighlightType.GENERIC_ERROR_OR_WARNING, ANNOTATE_OVERRIDDEN_METHODS_FIX); + ProblemHighlightType.GENERIC_ERROR_OR_WARNING, new AnnotateMethodFix(nullableManager.getDefaultNotNull(), ArrayUtil.toStringArray(nullableManager.getNullables())){ + protected boolean annotateOverriddenMethods() { + return true; + } + + @NotNull + public String getName() { + return InspectionsBundle.message("annotate.overridden.methods.as.notnull"); + } + }); methodQuickFixSuggested = true; } if (hasAnnotatedParameter) { @@ -346,12 +358,13 @@ public class NullableStuffInspection extends BaseLocalInspectionTool { for (int i = 0; i < psiParameters.length; i++) { if (parameterQuickFixSuggested[i]) continue; PsiParameter parameter = psiParameters[i]; - if (parameterAnnotated[i] && !AnnotationUtil.isAnnotated(parameter, AnnotationUtil.NOT_NULL, false)) { + if (parameterAnnotated[i] && !nullableManager.isNotNull(parameter, false)) { parameters[i].getNameIdentifier(); //be sure that corresponding tree element available - PsiAnnotation annotation = AnnotationUtil.findAnnotation(parameters[i], AnnotationUtil.NOT_NULL); + PsiAnnotation annotation = AnnotationUtil.findAnnotation(parameters[i], nullableManager.getNotNulls()); holder.registerProblem(annotation, InspectionsBundle.message("nullable.stuff.problems.overridden.method.parameters.are.not.annotated"), - ProblemHighlightType.GENERIC_ERROR_OR_WARNING, ANNOTATE_OVERRIDDEN_METHODS_PARAMS_FIX); + ProblemHighlightType.GENERIC_ERROR_OR_WARNING, + new AnnotateOverriddenMethodParameterFix(nullableManager.getDefaultNotNull(), nullableManager.getDefaultNullable())); parameterQuickFixSuggested[i] = true; } } @@ -362,7 +375,8 @@ public class NullableStuffInspection extends BaseLocalInspectionTool { } protected int annotateBaseMethod(final PsiMethod method, final PsiMethod superMethod, final Project project) { - return new AnnotateMethodFix(AnnotationUtil.NOT_NULL, AnnotationUtil.NULLABLE).annotateBaseMethod(method, superMethod, project); + final NullableNotNullManager manager = NullableNotNullManager.getInstance(project); + return new AnnotateMethodFix(manager.getDefaultNotNull(), ArrayUtil.toStringArray(manager.getNullables())).annotateBaseMethod(method, superMethod, project); } private static void reportNullableNotNullConflict(final ProblemsHolder holder, final PsiModifierListOwner listOwner, final PsiAnnotation declaredNullable, diff --git a/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java b/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java index 6a4573cf6048..1f4a41cac37f 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java @@ -18,7 +18,9 @@ package com.intellij.refactoring.extractMethod; import com.intellij.codeInsight.AnnotationUtil; import com.intellij.codeInsight.ChangeContextUtil; import com.intellij.codeInsight.ExceptionUtil; +import com.intellij.codeInsight.NullableNotNullManager; import com.intellij.codeInsight.highlighting.HighlightManager; +import com.intellij.codeInsight.intention.impl.AddNullableAnnotationFix; import com.intellij.codeInsight.intention.impl.AddNullableNotNullAnnotationFix; import com.intellij.codeInspection.dataFlow.RunnerResult; import com.intellij.codeInspection.dataFlow.StandardDataFlowRunner; @@ -957,11 +959,11 @@ public class ExtractMethodProcessor implements MatchProvider { if (myNullConditionalCheck) { final boolean isNullCheckReturnNull = (myHasExpressionOutput ? 1 : 0) + (myGenerateConditionalExit ? 1 : 0) + myOutputVariables.length <= 1; if (isNullCheckReturnNull && PsiUtil.isLanguageLevel5OrHigher(myElements[0])) { + final NullableNotNullManager manager = NullableNotNullManager.getInstance(myProject); final PsiClass nullableAnnotationClass = - JavaPsiFacade.getInstance(myProject).findClass(AnnotationUtil.NULLABLE, GlobalSearchScope.allScope(myProject)); + JavaPsiFacade.getInstance(myProject).findClass(manager.getDefaultNullable(), GlobalSearchScope.allScope(myProject)); if (nullableAnnotationClass != null) { - new AddNullableNotNullAnnotationFix(AnnotationUtil.NULLABLE, newMethod, AnnotationUtil.NOT_NULL) - .invoke(myProject, myEditor, myTargetClass.getContainingFile()); + new AddNullableAnnotationFix(newMethod).invoke(myProject, myEditor, myTargetClass.getContainingFile()); } } } diff --git a/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectProcessor.java b/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectProcessor.java index cd264b9a01b5..02a47b003d44 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectProcessor.java @@ -21,6 +21,7 @@ package com.intellij.refactoring.extractMethodObject; import com.intellij.codeInsight.AnnotationUtil; +import com.intellij.codeInsight.NullableNotNullManager; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.editor.Editor; @@ -524,8 +525,9 @@ public class ExtractMethodObjectProcessor extends BaseRefactoringProcessor { final PsiModifierList modifierList = field.getModifierList(); LOG.assertTrue(modifierList != null); - if (AnnotationUtil.isAnnotated(parameter, AnnotationUtil.NULLABLE, false)) { - modifierList.addAfter(myElementFactory.createAnnotationFromText("@" + AnnotationUtil.NULLABLE, field), null); + final NullableNotNullManager manager = NullableNotNullManager.getInstance(myProject); + if (manager.isNullable(parameter, false)) { + modifierList.addAfter(myElementFactory.createAnnotationFromText("@" + manager.getDefaultNullable(), field), null); } modifierList.setModifierProperty(PsiModifier.FINAL, isFinal); diff --git a/java/java-impl/src/com/intellij/refactoring/inheritanceToDelegation/InheritanceToDelegationProcessor.java b/java/java-impl/src/com/intellij/refactoring/inheritanceToDelegation/InheritanceToDelegationProcessor.java index 9e842d7bccb7..ec14b43ba5a9 100644 --- a/java/java-impl/src/com/intellij/refactoring/inheritanceToDelegation/InheritanceToDelegationProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/inheritanceToDelegation/InheritanceToDelegationProcessor.java @@ -16,6 +16,7 @@ package com.intellij.refactoring.inheritanceToDelegation; import com.intellij.codeInsight.AnnotationUtil; +import com.intellij.codeInsight.NullableNotNullManager; import com.intellij.codeInsight.generation.GenerateMembersUtil; import com.intellij.find.findUsages.PsiElement2UsageTargetAdapter; import com.intellij.openapi.diagnostic.Logger; @@ -522,12 +523,13 @@ public class InheritanceToDelegationProcessor extends BaseRefactoringProcessor { PsiMethod methodToAdd = GenerateMembersUtil.substituteGenericMethod(method, substitutor); final PsiModifierList modifierList = methodToAdd.getModifierList(); + final NullableNotNullManager manager = NullableNotNullManager.getInstance(myProject); modifierList.setModifierProperty(PsiModifier.ABSTRACT, false); - if (AnnotationUtil.isAnnotated(method, AnnotationUtil.NULLABLE, false)) { - modifierList.addAfter(myFactory.createAnnotationFromText("@" + AnnotationUtil.NULLABLE, methodToAdd), null); + if (manager.isNullable(method, false)) { + modifierList.addAfter(myFactory.createAnnotationFromText("@" + manager.getDefaultNullable(), methodToAdd), null); } - else if (AnnotationUtil.isAnnotated(method, AnnotationUtil.NOT_NULL, false)) { - modifierList.addAfter(myFactory.createAnnotationFromText("@" + AnnotationUtil.NOT_NULL, methodToAdd), null); + else if (manager.isNotNull(method, false)) { + modifierList.addAfter(myFactory.createAnnotationFromText("@" + manager.getDefaultNotNull(), methodToAdd), null); } final String delegationBody = getDelegationBody(methodToAdd, delegationTarget); diff --git a/java/openapi/src/com/intellij/codeInsight/AnnotationUtil.java b/java/openapi/src/com/intellij/codeInsight/AnnotationUtil.java index babac3920ad7..7101181e2c31 100644 --- a/java/openapi/src/com/intellij/codeInsight/AnnotationUtil.java +++ b/java/openapi/src/com/intellij/codeInsight/AnnotationUtil.java @@ -76,11 +76,11 @@ public class AnnotationUtil { } public static boolean isNullable(@NotNull PsiModifierListOwner owner) { - return !isNotNull(owner) && isAnnotated(owner, NULLABLE, true); + return !isNotNull(owner) && NullableNotNullManager.getInstance(owner.getProject()).isNullable(owner, true); } public static boolean isNotNull(@NotNull PsiModifierListOwner owner) { - return isAnnotated(owner, NOT_NULL, true); + return NullableNotNullManager.getInstance(owner.getProject()).isNotNull(owner, true); } @Nullable @@ -198,8 +198,14 @@ public class AnnotationUtil { } public static boolean isAnnotated(PsiModifierListOwner listOwner, Collection annotations) { + return isAnnotated(listOwner, annotations, false); + } + + public static boolean isAnnotated(PsiModifierListOwner listOwner, + Collection annotations, + final boolean checkHierarchy) { for (String annotation : annotations) { - if (isAnnotated(listOwner, annotation, false)) return true; + if (isAnnotated(listOwner, annotation, checkHierarchy)) return true; } return false; } diff --git a/java/openapi/src/com/intellij/codeInsight/NullableNotNullDialog.java b/java/openapi/src/com/intellij/codeInsight/NullableNotNullDialog.java new file mode 100644 index 000000000000..fb65255569fe --- /dev/null +++ b/java/openapi/src/com/intellij/codeInsight/NullableNotNullDialog.java @@ -0,0 +1,186 @@ +/* + * Copyright 2000-2011 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; + +import com.intellij.ide.ui.ListCellRendererWrapper; +import com.intellij.ide.util.ClassFilter; +import com.intellij.ide.util.TreeClassChooser; +import com.intellij.ide.util.TreeClassChooserFactory; +import com.intellij.openapi.actionSystem.*; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.ui.DialogWrapper; +import com.intellij.openapi.ui.VerticalFlowLayout; +import com.intellij.openapi.util.Comparing; +import com.intellij.openapi.util.IconLoader; +import com.intellij.psi.JavaPsiFacade; +import com.intellij.psi.PsiClass; +import com.intellij.psi.search.GlobalSearchScope; +import com.intellij.ui.LayeredIcon; +import com.intellij.ui.ScrollPaneFactory; +import com.intellij.ui.components.JBList; +import com.intellij.util.ArrayUtil; +import com.intellij.util.Icons; +import com.intellij.util.ui.EmptyIcon; +import com.intellij.util.ui.UIUtil; +import org.jetbrains.annotations.NonNls; + +import javax.swing.*; +import java.awt.*; +import java.util.ArrayList; +import java.util.List; + +/** + * User: anna + * Date: 1/25/11 + */ +public class NullableNotNullDialog extends DialogWrapper { + @NonNls private static final String GENERAL_ADD_ICON_PATH = "/general/add.png"; + private static final Icon ADD_ICON = IconLoader.getIcon(GENERAL_ADD_ICON_PATH); + private static final Icon REMOVE_ICON = IconLoader.getIcon("/general/remove.png"); + private static final Icon SAVE_ICON = IconLoader.getIcon("/ide/defaultProfile.png"); + + private final Project myProject; + private AnnoPanel myNullablePanel; + private AnnoPanel myNotNullPanel; + + public NullableNotNullDialog(Project project) { + super(project, true); + myProject = project; + init(); + setTitle("Nullable/NotNull configuration"); + } + + @Override + protected JComponent createCenterPanel() { + final JPanel panel = new JPanel(new VerticalFlowLayout()); + final NullableNotNullManager manager = NullableNotNullManager.getInstance(myProject); + myNullablePanel = + new AnnoPanel("Nullable", manager.getDefaultNullable(), manager.getNullables(), NullableNotNullManager.DEFAULT_NULLABLES); + panel.add(myNullablePanel); + myNotNullPanel = new AnnoPanel("NotNull", manager.getDefaultNotNull(), manager.getNotNulls(), NullableNotNullManager.DEFAULT_NOT_NULLS); + panel.add(myNotNullPanel); + return panel; + } + + + @Override + protected void doOKAction() { + final NullableNotNullManager manager = NullableNotNullManager.getInstance(myProject); + + manager.setNotNulls(myNotNullPanel.getAnns()); + manager.setDefaultNotNull(myNotNullPanel.getDefaultAnn()); + + manager.setNullables(myNullablePanel.getAnns()); + manager.setDefaultNullable(myNullablePanel.getDefaultAnn()); + + super.doOKAction(); + } + + private class AnnoPanel extends JPanel { + private String myDefaultAnn; + private final String[] myDefaultAnns; + private final JBList myList; + + private AnnoPanel(final String title, final String defaultAnn, final List anns, final String[] defaultAnns) { + super(new BorderLayout()); + myDefaultAnn = defaultAnn; + myDefaultAnns = defaultAnns; + setBorder(BorderFactory.createTitledBorder(title)); + myList = new JBList(anns); + myList.setCellRenderer(new DefaultListCellRenderer(){ + @Override + public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) { + final Component component = super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus); + if (Comparing.strEqual((String)value, myDefaultAnn)) { + setIcon(Icons.ADVICE_ICON); + setFont(UIUtil.getLabelFont().deriveFont(Font.BOLD)); + } + else { + setIcon(EmptyIcon.ICON_16); + } + setText((String)value); + return component; + } + }); + myList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); + myList.setSelectedValue(defaultAnn, true); + add(ScrollPaneFactory.createScrollPane(myList), BorderLayout.CENTER); + final DefaultActionGroup group = new DefaultActionGroup(); + group.add(new AnAction("Add", "Add", ADD_ICON) { + { + registerCustomShortcutSet(CommonShortcuts.INSERT, myList); + } + + @Override + public void actionPerformed(AnActionEvent e) { + chooseAnnotation(title, myList, null); + } + }); + group.add(new AnAction("Delete", "Delete", REMOVE_ICON) { + { + registerCustomShortcutSet(CommonShortcuts.DELETE, myList); + } + + @Override + public void update(AnActionEvent e) { + final Object selectedValue = myList.getSelectedValue(); + e.getPresentation().setEnabled(ArrayUtil.find(myDefaultAnns, selectedValue) == -1); + } + + @Override + public void actionPerformed(AnActionEvent e) { + ((DefaultListModel)myList.getModel()).removeElement(myList.getSelectedValue()); + } + }); + group.add(new AnAction("Make default", "Default", SAVE_ICON) { + @Override + public void update(AnActionEvent e) { + e.getPresentation().setEnabled(!Comparing.strEqual(myDefaultAnn, (String)myList.getSelectedValue())); + } + + @Override + public void actionPerformed(AnActionEvent e) { + myDefaultAnn = (String)myList.getSelectedValue(); + } + }); + add(ActionManager.getInstance().createActionToolbar(ActionPlaces.UNKNOWN, group, true).getComponent(), BorderLayout.NORTH); + } + + private void chooseAnnotation(String title, JBList list, PsiClass initial) { + final TreeClassChooser chooser = TreeClassChooserFactory.getInstance(myProject) + .createNoInnerClassesScopeChooser("Choose " + title, GlobalSearchScope.allScope(myProject), new ClassFilter() { + @Override + public boolean isAccepted(PsiClass aClass) { + return aClass.isAnnotationType(); + } + }, initial); + chooser.showDialog(); + final PsiClass selected = chooser.getSelected(); + if (selected != null) { + final String qualifiedName = selected.getQualifiedName(); + ((DefaultListModel)list.getModel()).addElement(qualifiedName); + } + } + + public String getDefaultAnn() { + return myDefaultAnn; + } + + public Object[] getAnns() { + return ((DefaultListModel)myList.getModel()).toArray(); + } + } +} diff --git a/java/openapi/src/com/intellij/codeInsight/NullableNotNullManager.java b/java/openapi/src/com/intellij/codeInsight/NullableNotNullManager.java new file mode 100644 index 000000000000..004d5b7861c1 --- /dev/null +++ b/java/openapi/src/com/intellij/codeInsight/NullableNotNullManager.java @@ -0,0 +1,141 @@ +/* + * Copyright 2000-2011 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; + +import com.intellij.openapi.components.PersistentStateComponent; +import com.intellij.openapi.components.ServiceManager; +import com.intellij.openapi.components.State; +import com.intellij.openapi.components.Storage; +import com.intellij.openapi.diagnostic.Logger; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.*; +import com.intellij.psi.PsiModifierListOwner; +import org.jdom.Element; +import org.jetbrains.annotations.NotNull; + +import java.util.*; + +/** + * User: anna + * Date: 1/25/11 + */ +@State( + name = "NullableNotNullManager", + storages = {@Storage(id = "default", file = "$PROJECT_FILE$")} +) +public class NullableNotNullManager implements PersistentStateComponent { + private static final Logger LOG = Logger.getInstance("#" + NullableNotNullManager.class.getName()); + + public String myDefaultNullable = AnnotationUtil.NULLABLE; + + public String myDefaultNotNull = AnnotationUtil.NOT_NULL; + public JDOMExternalizableStringList myNullables = new JDOMExternalizableStringList(); + public JDOMExternalizableStringList myNotNulls = new JDOMExternalizableStringList(); + + public static final String[] DEFAULT_NULLABLES = {AnnotationUtil.NULLABLE, "javax.annotation.Nullable", "edu.umd.cs.findbugs.annotations.Nullable"}; + public static final String[] DEFAULT_NOT_NULLS = {AnnotationUtil.NOT_NULL, "javax.annotation.Nonnull", "edu.umd.cs.findbugs.annotations.NonNull"}; + + public static NullableNotNullManager getInstance(Project project) { + return ServiceManager.getService(project, NullableNotNullManager.class); + } + + public Collection getAllAnnotations() { + final List all = new ArrayList(getNullables()); + all.addAll(getNotNulls()); + return all; + } + + public void setNotNulls(Object[] anns) { + myNotNulls.clear(); + for (Object ann : anns) { + myNotNulls.add((String)ann); + } + } + + public void setNullables(Object[] anns) { + myNullables.clear(); + for (Object ann : anns) { + myNullables.add((String)ann); + } + } + + public String getDefaultNullable() { + return myDefaultNullable; + } + + public void setDefaultNullable(@NotNull String defaultNullable) { + LOG.assertTrue(myNullables.contains(defaultNullable)); + myDefaultNullable = defaultNullable; + } + + public String getDefaultNotNull() { + return myDefaultNotNull; + } + + public void setDefaultNotNull(@NotNull String defaultNotNull) { + LOG.assertTrue(myNotNulls.contains(defaultNotNull)); + myDefaultNotNull = defaultNotNull; + } + + public List getNullables() { + if (myNullables.isEmpty()) { + Collections.addAll(myNullables, DEFAULT_NULLABLES); + } + return myNullables; + } + + public boolean isNullable(PsiModifierListOwner owner, boolean checkBases) { + return AnnotationUtil.isAnnotated(owner, getNullables(), checkBases); + } + + public boolean isNotNull(PsiModifierListOwner owner, boolean checkBases) { + return AnnotationUtil.isAnnotated(owner, getNotNulls(), checkBases); + } + + public List getNotNulls() { + if (myNotNulls.isEmpty()) { + Collections.addAll(myNotNulls, DEFAULT_NOT_NULLS); + } + return myNotNulls; + } + + @Override + public Element getState() { + final Element component = new Element("component"); + + if (getNullables().size() == DEFAULT_NULLABLES.length && getNotNulls().size() == DEFAULT_NOT_NULLS.length) { + return component; + } + + try { + DefaultJDOMExternalizer.writeExternal(this, component); + } + catch (WriteExternalException e) { + LOG.error(e); + } + return component; + } + + @Override + public void loadState(Element state) { + try { + DefaultJDOMExternalizer.readExternal(this, state); + } + catch (InvalidDataException e) { + LOG.error(e); + } + } +} diff --git a/java/openapi/src/com/intellij/psi/util/PropertyUtil.java b/java/openapi/src/com/intellij/psi/util/PropertyUtil.java index c95b41fecda4..739faa2c8e2b 100644 --- a/java/openapi/src/com/intellij/psi/util/PropertyUtil.java +++ b/java/openapi/src/com/intellij/psi/util/PropertyUtil.java @@ -16,6 +16,7 @@ package com.intellij.psi.util; import com.intellij.codeInsight.AnnotationUtil; +import com.intellij.codeInsight.NullableNotNullManager; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Comparing; @@ -474,11 +475,12 @@ public class PropertyUtil { private static void annotateWithNullableStuff(final PsiModifierListOwner field, final PsiElementFactory factory, final PsiModifierListOwner listOwner) throws IncorrectOperationException { - if (AnnotationUtil.isAnnotated(field, AnnotationUtil.NOT_NULL, false)) { - annotate(factory, listOwner, AnnotationUtil.NOT_NULL); + final NullableNotNullManager manager = NullableNotNullManager.getInstance(field.getProject()); + if (manager.isNotNull(field, false)) { + annotate(factory, listOwner, manager.getDefaultNotNull()); } - else if (AnnotationUtil.isAnnotated(field, AnnotationUtil.NULLABLE, false)) { - annotate(factory, listOwner, AnnotationUtil.NULLABLE); + else if (manager.isNullable(field, false)) { + annotate(factory, listOwner, manager.getDefaultNullable()); } } diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/bugs/ReturnNullInspection.java b/plugins/InspectionGadgets/src/com/siyeh/ig/bugs/ReturnNullInspection.java index f43657d41f3b..e54ac775a86a 100644 --- a/plugins/InspectionGadgets/src/com/siyeh/ig/bugs/ReturnNullInspection.java +++ b/plugins/InspectionGadgets/src/com/siyeh/ig/bugs/ReturnNullInspection.java @@ -16,9 +16,11 @@ package com.siyeh.ig.bugs; import com.intellij.codeInsight.AnnotationUtil; +import com.intellij.codeInsight.NullableNotNullManager; import com.intellij.codeInspection.AnnotateMethodFix; import com.intellij.psi.*; import com.intellij.psi.util.PsiTreeUtil; +import com.intellij.util.ArrayUtil; import com.siyeh.InspectionGadgetsBundle; import com.siyeh.ig.BaseInspection; import com.siyeh.ig.BaseInspectionVisitor; @@ -58,11 +60,13 @@ public class ReturnNullInspection extends BaseInspection { @Nullable protected InspectionGadgetsFix buildFix(Object... infos) { - if (!AnnotationUtil.isAnnotatingApplicable((PsiElement) infos[0])) { + final PsiElement elt = (PsiElement)infos[0]; + if (!AnnotationUtil.isAnnotatingApplicable(elt)) { return null; } - return new DelegatingFix(new AnnotateMethodFix( - AnnotationUtil.NULLABLE, AnnotationUtil.NOT_NULL)); + final NullableNotNullManager manager = NullableNotNullManager.getInstance(elt.getProject()); + return new DelegatingFix(new AnnotateMethodFix( + manager.getDefaultNullable(), ArrayUtil.toStringArray(manager.getNotNulls()))); } public JComponent createOptionsPanel() { @@ -110,8 +114,7 @@ public class ReturnNullInspection extends BaseInspection { return; } final boolean isArray = returnType.getArrayDimensions() > 0; - if (AnnotationUtil.isAnnotated(method, AnnotationUtil.NULLABLE, - false)) { + if (NullableNotNullManager.getInstance(method.getProject()).isNullable(method, false)) { return; } if (m_reportCollectionMethods && @@ -124,4 +127,4 @@ public class ReturnNullInspection extends BaseInspection { } } } -} \ No newline at end of file +} diff --git a/plugins/testng/src/com/theoryinpractice/testng/intention/OverrideImplementsTestNGAnnotationsHandler.java b/plugins/testng/src/com/theoryinpractice/testng/intention/OverrideImplementsTestNGAnnotationsHandler.java index 1897355ec8b5..d0eb0b03db50 100644 --- a/plugins/testng/src/com/theoryinpractice/testng/intention/OverrideImplementsTestNGAnnotationsHandler.java +++ b/plugins/testng/src/com/theoryinpractice/testng/intention/OverrideImplementsTestNGAnnotationsHandler.java @@ -21,18 +21,19 @@ package com.theoryinpractice.testng.intention; import com.intellij.codeInsight.generation.OverrideImplementsAnnotationsHandler; +import com.intellij.openapi.project.Project; import com.intellij.util.ArrayUtil; import com.theoryinpractice.testng.util.TestNGUtil; import org.jetbrains.annotations.NotNull; public class OverrideImplementsTestNGAnnotationsHandler implements OverrideImplementsAnnotationsHandler{ - public String[] getAnnotations() { + public String[] getAnnotations(Project project) { return TestNGUtil.CONFIG_ANNOTATIONS_FQN; } @NotNull - public String[] annotationsToRemove(@NotNull final String fqName) { + public String[] annotationsToRemove(Project project, @NotNull final String fqName) { return ArrayUtil.EMPTY_STRING_ARRAY; } } \ No newline at end of file diff --git a/resources-en/src/inspectionDescriptions/NullableProblems.html b/resources-en/src/inspectionDescriptions/NullableProblems.html index da66aec58b48..32eb77ca8675 100644 --- a/resources-en/src/inspectionDescriptions/NullableProblems.html +++ b/resources-en/src/inspectionDescriptions/NullableProblems.html @@ -1,8 +1,8 @@ This inspection reports problems related to - @org.jetbrains.annotations.Nullable and @org.jetbrains.annotations.NotNull - annotations usage. + @Nullable and @NotNull + annotations usage configured in Constant conditions & exceptions inspection.
diff --git a/resources/src/META-INF/IdeaPlugin.xml b/resources/src/META-INF/IdeaPlugin.xml index 0fe6db6ebcdd..2eb8ce20323e 100644 --- a/resources/src/META-INF/IdeaPlugin.xml +++ b/resources/src/META-INF/IdeaPlugin.xml @@ -447,6 +447,9 @@ + +