From cc551074c437fbc5edbd4846e761e1e39bc7e35b Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Tue, 24 Apr 2018 13:24:56 +0200
Subject: [PATCH] NullableStuffInspection: check overriding params when method
 is annotated (IDEA-190774)

---
 .../nullable/NullableStuffInspectionBase.java | 29 +++++++++----------
 .../nullableProblems/OverriddenMethods.java   | 16 +++++++++-
 2 files changed, 28 insertions(+), 17 deletions(-)

diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspectionBase.java b/java/java-analysis-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspectionBase.java
index 5f2c68725b3a..20516020dd6a 100644
--- a/java/java-analysis-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspectionBase.java
+++ b/java/java-analysis-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspectionBase.java
@@ -853,24 +853,18 @@ public class NullableStuffInspectionBase extends AbstractBaseJavaLocalInspection
         for (PsiMethod overriding : overridings) {
           if (!manager.isInProject(overriding)) continue;
 
-          final boolean applicable = AnnotationUtil.isAnnotatingApplicable(overriding, defaultNotNull);
-          boolean ableToAddNotNullAnnotation = AddAnnotationPsiFix.isAvailable(overriding, defaultNotNull);
           if (!methodQuickFixSuggested
               && annotated.isDeclaredNotNull
               && !isNotNullNotInferred(overriding, false, false)
               && (isNullableNotInferred(overriding, false) || !isNullableNotInferred(overriding, true))
-              && ableToAddNotNullAnnotation) {
+              && AddAnnotationPsiFix.isAvailable(overriding, defaultNotNull)) {
             PsiIdentifier identifier = method.getNameIdentifier();//load tree
             PsiAnnotation annotation = AnnotationUtil.findAnnotation(method, nullableManager.getNotNulls());
             final String[] annotationsToRemove = ArrayUtil.toStringArray(nullableManager.getNullables());
 
-            final LocalQuickFix fix;
-            if (applicable) {
-              fix = new MyAnnotateMethodFix(defaultNotNull, annotationsToRemove);
-            }
-            else {
-              fix = superMethodApplicable ? null : createChangeDefaultNotNullFix(nullableManager, method);
-            }
+            LocalQuickFix fix = AnnotationUtil.isAnnotatingApplicable(overriding, defaultNotNull)
+                                ? new MyAnnotateMethodFix(defaultNotNull, annotationsToRemove)
+                                : superMethodApplicable ? null : createChangeDefaultNotNullFix(nullableManager, method);
 
             PsiElement psiElement = annotation;
             if (!annotation.isPhysical()) {
@@ -882,12 +876,15 @@ public class NullableStuffInspectionBase extends AbstractBaseJavaLocalInspection
                                    fix);
             methodQuickFixSuggested = true;
           }
-          if (hasAnnotatedParameter && ableToAddNotNullAnnotation) {
+          if (hasAnnotatedParameter) {
             PsiParameter[] psiParameters = overriding.getParameterList().getParameters();
             for (int i = 0; i < psiParameters.length; i++) {
               if (parameterQuickFixSuggested[i]) continue;
               PsiParameter parameter = psiParameters[i];
-              if (parameterAnnotated[i] && !isNotNullNotInferred(parameter, false, false) && !isNullableNotInferred(parameter, false)) {
+              if (parameterAnnotated[i] && 
+                  !isNotNullNotInferred(parameter, false, false) &&
+                  !isNullableNotInferred(parameter, false) &&
+                  AddAnnotationPsiFix.isAvailable(parameter, defaultNotNull)) {
                 PsiIdentifier identifier = parameters[i].getNameIdentifier(); //be sure that corresponding tree element available
                 PsiAnnotation annotation = AnnotationUtil.findAnnotation(parameters[i], nullableManager.getNotNulls());
                 PsiElement psiElement = annotation;
@@ -895,13 +892,13 @@ public class NullableStuffInspectionBase extends AbstractBaseJavaLocalInspection
                   psiElement = identifier;
                   if (psiElement == null) continue;
                 }
+                LocalQuickFix fix = AnnotationUtil.isAnnotatingApplicable(parameter, defaultNotNull)
+                                    ? new AnnotateOverriddenMethodParameterFix(defaultNotNull, nullableManager.getDefaultNullable())
+                                    : createChangeDefaultNotNullFix(nullableManager, parameters[i]);
                 holder.registerProblem(psiElement,
                                        InspectionsBundle.message("nullable.stuff.problems.overridden.method.parameters.are.not.annotated"),
                                        ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
-                                       !applicable
-                                       ? createChangeDefaultNotNullFix(nullableManager, parameters[i])
-                                       : new AnnotateOverriddenMethodParameterFix(defaultNotNull,
-                                                                                  nullableManager.getDefaultNullable()));
+                                       fix);
                 parameterQuickFixSuggested[i] = true;
               }
             }
diff --git a/java/java-tests/testData/inspection/nullableProblems/OverriddenMethods.java b/java/java-tests/testData/inspection/nullableProblems/OverriddenMethods.java
index 633bf556b048..55c7fd700cab 100644
--- a/java/java-tests/testData/inspection/nullableProblems/OverriddenMethods.java
+++ b/java/java-tests/testData/inspection/nullableProblems/OverriddenMethods.java
@@ -45,4 +45,18 @@ class A implements I1 {
 }
 
 class B extends A implements <warning descr="Non-annotated method 'foo' from 'A' implements non-null method from 'I2'">I2</warning> {
-}
\ No newline at end of file
+}
+
+interface InheritorMethodOverriddenButParameterNot {
+  @NotNull
+  Integer get(<warning descr="Overridden method parameters are not annotated">@NotNull</warning> String param);
+}
+
+class InheritorMethodOverriddenButParameterNot_Impl implements InheritorMethodOverriddenButParameterNot {
+
+  @NotNull
+  @Override
+  public Integer get(String <warning descr="Not annotated parameter overrides @NotNull parameter">param</warning>) {
+    return 1;
+  }
+}