diff --git a/.consulo/runConfigurations/consulo_run_desktop_awt.xml b/.consulo/runConfigurations/consulo_run_desktop_awt_fork.xml
similarity index 63%
rename from .consulo/runConfigurations/consulo_run_desktop_awt.xml
rename to .consulo/runConfigurations/consulo_run_desktop_awt_fork.xml
index 21a144a7c1..668876e5b5 100644
--- a/.consulo/runConfigurations/consulo_run_desktop_awt.xml
+++ b/.consulo/runConfigurations/consulo_run_desktop_awt_fork.xml
@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="consulo:run-desktop-awt" type="MavenRunConfiguration" factoryName="Maven" singleton="true">
+  <configuration default="false" name="consulo:run-desktop-awt-fork" type="MavenRunConfiguration" factoryName="Maven" singleton="true">
     <MavenSettings>
       <option name="myGeneralSettings" />
       <option name="myRunnerSettings">
@@ -14,7 +14,7 @@
           <option name="passParentEnv" value="true" />
           <option name="runMavenInBackground" value="true" />
           <option name="skipTests" value="false" />
-          <option name="vmOptions" value="--add-opens=java.desktop/sun.awt=ALL-UNNAMED --add-opens=java.desktop/sun.swing=ALL-UNNAMED --add-opens=java.desktop/sun.awt.image=ALL-UNNAMED --add-opens=java.desktop/sun.java2d=ALL-UNNAMED --add-opens=java.desktop/sun.font=ALL-UNNAMED --add-opens=java.desktop/java.awt=ALL-UNNAMED --add-opens=java.desktop/javax.swing=ALL-UNNAMED --add-opens=java.desktop/javax.swing.plaf.basic=ALL-UNNAMED --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.desktop/javax.swing.text.html=ALL-UNNAMED --add-opens=java.desktop/java.awt.peer=ALL-UNNAMED --add-opens=java.desktop/java.awt.event=ALL-UNNAMED" />
+          <option name="vmOptions" value="" />
         </MavenRunnerSettings>
       </option>
       <option name="myRunnerParameters">
@@ -24,7 +24,7 @@
           </option>
           <option name="goals">
             <list>
-              <option value="consulo:run-desktop-awt" />
+              <option value="consulo:run-desktop-awt-fork" />
               <option value="-pl" />
               <option value=":consulo.java" />
             </list>
diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/RemoveAnnotationQuickFix.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/RemoveAnnotationQuickFix.java
index 7c345a39c2..7919e026f5 100644
--- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/RemoveAnnotationQuickFix.java
+++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/RemoveAnnotationQuickFix.java
@@ -22,40 +22,56 @@
 import consulo.language.editor.inspection.LocalQuickFix;
 import consulo.language.editor.inspection.ProblemDescriptor;
 import consulo.language.editor.localize.CodeInsightLocalize;
+import consulo.language.psi.SmartPointerManager;
+import consulo.language.psi.SmartPsiElementPointer;
 import consulo.language.util.IncorrectOperationException;
 import consulo.localize.LocalizeValue;
 import consulo.logging.Logger;
 import consulo.project.Project;
+import org.jetbrains.annotations.NotNull;
+import org.jspecify.annotations.Nullable;
 
 /**
  * @author yole
  */
 public class RemoveAnnotationQuickFix implements LocalQuickFix {
-  private static final Logger LOG = Logger.getInstance(RemoveAnnotationQuickFix.class);
-  private final PsiAnnotation myAnnotation;
-  private final PsiModifierListOwner myListOwner;
+    private static final Logger LOG = Logger.getInstance(RemoveAnnotationQuickFix.class);
+    private final SmartPsiElementPointer<PsiAnnotation> myAnnotation;
+    private final SmartPsiElementPointer<PsiModifierListOwner> myListOwner;
+    private final boolean myRemoveInheritors;
 
-  public RemoveAnnotationQuickFix(PsiAnnotation annotation, final PsiModifierListOwner listOwner) {
-    myAnnotation = annotation;
-    myListOwner = listOwner;
-  }
+    public RemoveAnnotationQuickFix(@NotNull PsiAnnotation annotation, @Nullable PsiModifierListOwner listOwner) {
+        this(annotation, listOwner, false);
+    }
+
+    public RemoveAnnotationQuickFix(@NotNull PsiAnnotation annotation, @Nullable PsiModifierListOwner listOwner, boolean removeInheritors) {
+        Project project = annotation.getProject();
+        SmartPointerManager pm = SmartPointerManager.getInstance(project);
+        myAnnotation = pm.createSmartPsiElementPointer(annotation);
+        myListOwner = listOwner == null ? null : pm.createSmartPsiElementPointer(listOwner);
+        myRemoveInheritors = removeInheritors;
+    }
 
-  @Override
-  public LocalizeValue getName() {
-    return CodeInsightLocalize.removeAnnotation();
-  }
+    @Override
+    public LocalizeValue getName() {
+        return CodeInsightLocalize.removeAnnotation();
+    }
 
-  @Override
-  public void applyFix(Project project, ProblemDescriptor descriptor) {
-    if (myAnnotation.isPhysical()) {
-      try {
-        if (!FileModificationService.getInstance().preparePsiElementForWrite(myAnnotation)) return;
-        myAnnotation.delete();
-      } catch (IncorrectOperationException e) {
-        LOG.error(e);
-      }
-    } else {
-      ExternalAnnotationsManager.getInstance(project).deannotate(myListOwner, myAnnotation.getQualifiedName());
+    @Override
+    public void applyFix(Project project, ProblemDescriptor descriptor) {
+        if (myAnnotation.isPhysical()) {
+            try {
+                if (!FileModificationService.getInstance().preparePsiElementForWrite(myAnnotation)) {
+                    return;
+                }
+                myAnnotation.delete();
+            }
+            catch (IncorrectOperationException e) {
+                LOG.error(e);
+            }
+        }
+        else {
+            ExternalAnnotationsManager.getInstance(project).deannotate(myListOwner, myAnnotation.getQualifiedName());
+        }
     }
-  }
 }
\ No newline at end of file
diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/DfaPsiUtil.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/DfaPsiUtil.java
index a3330595ff..3cc8b33c66 100644
--- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/DfaPsiUtil.java
+++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/DfaPsiUtil.java
@@ -9,10 +9,7 @@
 import com.intellij.java.analysis.impl.codeInspection.dataFlow.types.DfTypes;
 import com.intellij.java.analysis.impl.codeInspection.util.OptionalUtil;
 import com.intellij.java.language.JavaLanguage;
-import com.intellij.java.language.codeInsight.AnnotationUtil;
-import com.intellij.java.language.codeInsight.Nullability;
-import com.intellij.java.language.codeInsight.NullabilityAnnotationInfo;
-import com.intellij.java.language.codeInsight.NullableNotNullManager;
+import com.intellij.java.language.codeInsight.*;
 import com.intellij.java.language.codeInsight.daemon.impl.analysis.JavaGenericsUtil;
 import com.intellij.java.language.psi.*;
 import com.intellij.java.language.psi.search.searches.DeepestSuperMethodsSearch;
@@ -28,12 +25,16 @@
 import consulo.language.psi.search.ReferencesSearch;
 import consulo.language.psi.util.LanguageCachedValueUtil;
 import consulo.language.psi.util.PsiTreeUtil;
+import consulo.project.DumbService;
+import consulo.project.Project;
 import consulo.util.collection.Stack;
 import consulo.util.collection.*;
 import consulo.util.lang.ObjectUtil;
 import consulo.util.lang.ref.Ref;
-
+import one.util.streamex.StreamEx;
+import org.jetbrains.annotations.NotNull;
 import org.jspecify.annotations.Nullable;
+
 import java.util.*;
 import java.util.function.Function;
 
@@ -42,579 +43,638 @@
 
 public final class DfaPsiUtil {
 
-  private static final CallMatcher NON_NULL_VAR_ARG = CallMatcher.anyOf(
-      staticCall(JAVA_UTIL_LIST, "of"),
-      staticCall(JAVA_UTIL_SET, "of"),
-      staticCall(JAVA_UTIL_MAP, "ofEntries"));
-
-  public static boolean isFinalField(PsiVariable var) {
-    return var.hasModifierProperty(PsiModifier.FINAL) && !var.hasModifierProperty(PsiModifier.TRANSIENT) && var instanceof PsiField;
-  }
-
-  public static Nullability getElementNullability(@Nullable PsiType resultType, @Nullable PsiModifierListOwner owner) {
-    return getElementNullability(resultType, owner, false);
-  }
-
-  public static Nullability getElementNullabilityIgnoringParameterInference(@Nullable PsiType resultType,
-                                                                            @Nullable PsiModifierListOwner owner) {
-    return getElementNullability(resultType, owner, true);
-  }
-
-  private static Nullability getElementNullability(@Nullable PsiType resultType,
-                                                   @Nullable PsiModifierListOwner owner,
-                                                   boolean ignoreParameterNullabilityInference) {
-    if (owner == null) {
-      return getTypeNullability(resultType);
-    }
+    private static final CallMatcher NON_NULL_VAR_ARG = CallMatcher.anyOf(
+        staticCall(JAVA_UTIL_LIST, "of"),
+        staticCall(JAVA_UTIL_SET, "of"),
+        staticCall(JAVA_UTIL_MAP, "ofEntries"));
 
-    if (resultType instanceof PsiPrimitiveType) {
-      return Nullability.UNKNOWN;
+    public static boolean isFinalField(PsiVariable var) {
+        return var.hasModifierProperty(PsiModifier.FINAL) && !var.hasModifierProperty(PsiModifier.TRANSIENT) && var instanceof PsiField;
     }
 
-    if (owner instanceof PsiEnumConstant || PsiUtil.isAnnotationMethod(owner)) {
-      return Nullability.NOT_NULL;
-    }
-    if (owner instanceof PsiMethod && isEnumPredefinedMethod((PsiMethod) owner)) {
-      return Nullability.NOT_NULL;
+    /**
+     * Returns nullability of variable or method, when it's expected to read from it.
+     * This method takes into account various sources of nullability information, like method annotations,
+     * type annotations, container annotations, inferred annotations, or external annotations.
+     * Automatic inference of method parameter nullability is ignored, which is useful when analyzing the method body (as it's
+     * inferred from method body as well, so both analyses may produce conflicting results).
+     *
+     * @param resultType concrete type of particular variable access or method call (an instantiation of generic method return type,
+     *                   or variable type), if known.
+     * @param owner      method or variable to get its nullability
+     * @return nullability of the owner; {@link Nullability#UNKNOWN} is both parameters are null.
+     */
+    public static @NotNull Nullability getElementNullabilityForRead(@Nullable PsiType resultType, @Nullable PsiModifierListOwner owner) {
+        return getElementNullability(resultType, owner, true);
     }
 
-    Nullability fromAnnotation = getNullabilityFromAnnotation(owner, ignoreParameterNullabilityInference);
-    if (fromAnnotation != Nullability.UNKNOWN) {
-      return fromAnnotation;
+    public static Nullability getElementNullabilityIgnoringParameterInference(@Nullable PsiType resultType,
+                                                                              @Nullable PsiModifierListOwner owner) {
+        return getElementNullability(resultType, owner, true);
     }
 
-    if (owner instanceof PsiMethod && isMapMethodWithUnknownNullity((PsiMethod) owner)) {
-      return getTypeNullability(resultType) == Nullability.NULLABLE ? Nullability.NULLABLE : Nullability.UNKNOWN;
-    }
+    private static @NotNull Nullability getElementNullability(@Nullable PsiType resultType,
+                                                              @Nullable PsiModifierListOwner owner,
+                                                              boolean forRead) {
+        if (owner == null) return getTypeNullability(resultType, forRead);
 
-    Nullability fromType = getTypeNullability(resultType);
-    if (fromType != Nullability.UNKNOWN) {
-      return fromType;
-    }
+        if (resultType instanceof PsiPrimitiveType) {
+            return Nullability.UNKNOWN;
+        }
 
-    if (owner instanceof PsiParameter) {
-      return inferParameterNullability((PsiParameter) owner);
-    }
+        if (owner instanceof PsiEnumConstant) {
+            return Nullability.NOT_NULL;
+        }
 
-    if (owner instanceof PsiMethod && ((PsiMethod) owner).getParameterList().isEmpty()) {
-      PsiField field = PropertyUtil.getFieldOfGetter((PsiMethod) owner);
-      if (field != null && getElementNullability(resultType, field) == Nullability.NULLABLE) {
-        return Nullability.NULLABLE;
-      }
-    }
+        // Annotation manager requires index
+        Project project = owner.getProject();
+        if (DumbService.isDumb(project)) return Nullability.UNKNOWN;
+        NullabilityAnnotationInfo fromAnnotation = getNullabilityFromAnnotation(owner, forRead);
+        if (fromAnnotation != null) {
+            if (resultType != null && fromAnnotation.getNullability() != Nullability.NOT_NULL) {
+                PsiType type = PsiUtil.getTypeByPsiElement(owner);
+                if (type != null) {
+                    PsiAnnotationOwner annotationOwner = fromAnnotation.getAnnotation().getOwner();
+                    if (PsiUtil.resolveClassInClassTypeOnly(type) instanceof PsiTypeParameter tp &&
+                        annotationOwner instanceof PsiType && annotationOwner != type &&
+                        !tp.equals(PsiUtil.resolveClassInClassTypeOnly(resultType))) {
+                        // Nullable/Unknown from type hierarchy: should check the instantiation, as it could be more concrete
+                        return getTypeNullability(resultType, forRead);
+                    }
+                }
+            }
+            return fromAnnotation.getNullability();
+        }
 
-    return Nullability.UNKNOWN;
-  }
+        if (owner instanceof PsiMethod method) {
+            if (isEnumPredefinedMethod(method)) {
+                return Nullability.NOT_NULL;
+            }
+            if (isMapMethodWithUnknownNullity(method)) {
+                return getTypeNullability(resultType) == Nullability.NULLABLE ? Nullability.NULLABLE : Nullability.UNKNOWN;
+            }
+        }
 
-  private static Nullability getNullabilityFromAnnotation(PsiModifierListOwner owner, boolean ignoreParameterNullabilityInference) {
-    NullableNotNullManager manager = NullableNotNullManager.getInstance(owner.getProject());
-    NullabilityAnnotationInfo info = manager.findEffectiveNullabilityInfo(owner);
-    if (info == null || shouldIgnoreAnnotation(info.getAnnotation())) {
-      return Nullability.UNKNOWN;
-    }
-    if (ignoreParameterNullabilityInference && owner instanceof PsiParameter && AnnotationUtil.isInferredAnnotation(info.getAnnotation())) {
-      List<PsiParameter> supers = AnnotationUtil.getSuperAnnotationOwners((PsiParameter) owner);
-      return ContainerUtil.exists(supers, each -> manager.isNullable(each, false)) ? Nullability.NULLABLE : Nullability.UNKNOWN;
-    }
-    return info.getNullability();
-  }
+        if (owner instanceof PsiParameter parameter) {
+            Nullability nullability = inferParameterNullability(parameter);
+            if (nullability != Nullability.UNKNOWN) {
+                return nullability;
+            }
+        }
+
+        Nullability fromType = getNullabilityFromType(resultType, owner);
+        if (fromType != null) return fromType;
 
-  private static boolean isMapMethodWithUnknownNullity(PsiMethod method) {
-    String name = method.getName();
-    if (!"get".equals(name) && !"remove".equals(name)) {
-      return false;
+        if (owner instanceof PsiMethod method && method.getParameterList().isEmpty() && forRead) {
+            PsiField field = PropertyUtil.getFieldOfGetter(method);
+            if (field != null && getElementNullabilityForRead(resultType, field) == Nullability.NULLABLE) {
+                return Nullability.NULLABLE;
+            }
+        }
+
+        return Nullability.UNKNOWN;
+    }
+
+    private static @NotNull Nullability getTypeNullability(@Nullable PsiType type, boolean forRead) {
+        if (type == null) return Nullability.UNKNOWN;
+        if (type instanceof PsiCapturedWildcardType captured) {
+            if (!forRead) {
+                TypeNullability nullability = captured.getLowerBound().getNullability();
+                if (nullability.source() instanceof NullabilitySource.ExtendsBound) {
+                    PsiElement context = captured.getContext();
+                    NullableNotNullManager manager = NullableNotNullManager.getInstance(context.getProject());
+                    if (manager != null) {
+                        NullabilityAnnotationInfo defaultNullability = manager.findDefaultTypeUseNullability(context);
+                        if (defaultNullability != null && defaultNullability.getNullability() == Nullability.NOT_NULL) {
+                            return Nullability.NOT_NULL;
+                        }
+                    }
+                }
+                return nullability.nullability();
+            }
+        }
+        return type.getNullability().nullability();
     }
-    PsiMethod superMethod = DeepestSuperMethodsSearch.search(method).findFirst();
-    return ("java.util.Map." + name).equals(PsiUtil.getMemberQualifiedName(superMethod != null ? superMethod : method));
-  }
-
-  public static Nullability inferParameterNullability(PsiParameter parameter) {
-    PsiElement parent = parameter.getParent();
-    if (parent instanceof PsiParameterList) {
-      PsiElement gParent = parent.getParent();
-      if (gParent instanceof PsiLambdaExpression) {
-        return getFunctionalParameterNullability((PsiLambdaExpression) gParent, ((PsiParameterList) parent).getParameterIndex(parameter));
-      } else if (gParent instanceof PsiMethod && OptionalUtil.OPTIONAL_OF_NULLABLE.methodMatches((PsiMethod) gParent)) {
-        return Nullability.NULLABLE;
-      }
+
+    private static @Nullable Nullability getNullabilityFromType(@Nullable PsiType resultType, @NotNull PsiModifierListOwner owner) {
+        if (resultType == null) return null;
+        TypeNullability typeNullability = resultType.getNullability();
+        if (typeNullability.equals(TypeNullability.UNKNOWN)) return null;
+        Nullability fromType = typeNullability.nullability();
+        if (fromType == Nullability.NOT_NULL && hasNullContract(owner)) {
+            return Nullability.UNKNOWN;
+        }
+        return fromType;
     }
-    if (parent instanceof PsiForeachStatement) {
-      return getTypeNullability(inferLoopParameterTypeWithNullability((PsiForeachStatement) parent));
+
+    private static boolean hasNullContract(@NotNull PsiModifierListOwner owner) {
+        if (owner instanceof PsiParameter parameter && parameter.getDeclarationScope() instanceof PsiMethod method) {
+            int index = method.getParameterList().getParameterIndex(parameter);
+            List<StandardMethodContract> contracts = JavaMethodContractUtil.getMethodContracts(method);
+            return ContainerUtil.exists(contracts,
+                c -> c.getParameterConstraint(index) == StandardMethodContract.ValueConstraint.NULL_VALUE);
+        }
+        return false;
     }
-    return Nullability.UNKNOWN;
-  }
-
-  @Nullable
-  private static PsiType inferLoopParameterTypeWithNullability(PsiForeachStatement loop) {
-    PsiExpression iteratedValue = PsiUtil.skipParenthesizedExprDown(loop.getIteratedValue());
-    if (iteratedValue == null) {
-      return null;
+
+    private static @Nullable NullabilityAnnotationInfo getNullabilityFromAnnotation(@NotNull PsiModifierListOwner owner,
+                                                                                    boolean ignoreParameterNullabilityInference) {
+        NullableNotNullManager manager = NullableNotNullManager.getInstance(owner.getProject());
+        NullabilityAnnotationInfo info = manager.findEffectiveNullabilityInfo(owner);
+        if (info == null || shouldIgnoreAnnotation(info.getAnnotation())) {
+            return null;
+        }
+        if (ignoreParameterNullabilityInference && owner instanceof PsiParameter && info.isInferred()) {
+            List<PsiParameter> supers = AnnotationUtil.getSuperAnnotationOwners((PsiParameter) owner);
+            return StreamEx.of(supers).map(param -> manager.findEffectiveNullabilityInfo(param))
+                .findFirst(i -> i != null && i.getInheritedFrom() == null && i.getNullability() == Nullability.NULLABLE)
+                .orElse(null);
+        }
+        return info;
     }
 
-    PsiType iteratedType = iteratedValue.getType();
-    if (iteratedValue instanceof PsiReferenceExpression) {
-      PsiElement target = ((PsiReferenceExpression) iteratedValue).resolve();
-      if (target instanceof PsiParameter && target.getParent() instanceof PsiForeachStatement) {
-        PsiForeachStatement targetLoop = (PsiForeachStatement) target.getParent();
-        if (PsiTreeUtil.isAncestor(targetLoop, loop, true) &&
-            !HighlightControlFlowUtil.isReassigned((PsiParameter) target, new HashMap<>())) {
-          iteratedType = inferLoopParameterTypeWithNullability(targetLoop);
+    private static boolean isMapMethodWithUnknownNullity(PsiMethod method) {
+        String name = method.getName();
+        if (!"get".equals(name) && !"remove".equals(name)) {
+            return false;
         }
-      }
+        PsiMethod superMethod = DeepestSuperMethodsSearch.search(method).findFirst();
+        return ("java.util.Map." + name).equals(PsiUtil.getMemberQualifiedName(superMethod != null ? superMethod : method));
     }
-    return JavaGenericsUtil.getCollectionItemType(iteratedType, iteratedValue.getResolveScope());
-  }
 
+    public static Nullability inferParameterNullability(PsiParameter parameter) {
+        PsiElement parent = parameter.getParent();
+        if (parent instanceof PsiParameterList) {
+            PsiElement gParent = parent.getParent();
+            if (gParent instanceof PsiLambdaExpression) {
+                return getFunctionalParameterNullability((PsiLambdaExpression) gParent, ((PsiParameterList) parent).getParameterIndex(parameter));
+            }
+            else if (gParent instanceof PsiMethod && OptionalUtil.OPTIONAL_OF_NULLABLE.methodMatches((PsiMethod) gParent)) {
+                return Nullability.NULLABLE;
+            }
+        }
+        if (parent instanceof PsiForeachStatement) {
+            return getTypeNullability(inferLoopParameterTypeWithNullability((PsiForeachStatement) parent));
+        }
+        return Nullability.UNKNOWN;
+    }
 
-  public static Nullability getTypeNullability(@Nullable PsiType type) {
-    NullabilityAnnotationInfo info = getTypeNullabilityInfo(type);
-    return info == null ? Nullability.UNKNOWN : info.getNullability();
-  }
+    @Nullable
+    private static PsiType inferLoopParameterTypeWithNullability(PsiForeachStatement loop) {
+        PsiExpression iteratedValue = PsiUtil.skipParenthesizedExprDown(loop.getIteratedValue());
+        if (iteratedValue == null) {
+            return null;
+        }
 
-  @Nullable
-  public static NullabilityAnnotationInfo getTypeNullabilityInfo(@Nullable PsiType type) {
-    if (type == null || type instanceof PsiPrimitiveType) {
-      return null;
+        PsiType iteratedType = iteratedValue.getType();
+        if (iteratedValue instanceof PsiReferenceExpression) {
+            PsiElement target = ((PsiReferenceExpression) iteratedValue).resolve();
+            if (target instanceof PsiParameter && target.getParent() instanceof PsiForeachStatement) {
+                PsiForeachStatement targetLoop = (PsiForeachStatement) target.getParent();
+                if (PsiTreeUtil.isAncestor(targetLoop, loop, true) &&
+                    !HighlightControlFlowUtil.isReassigned((PsiParameter) target, new HashMap<>())) {
+                    iteratedType = inferLoopParameterTypeWithNullability(targetLoop);
+                }
+            }
+        }
+        return JavaGenericsUtil.getCollectionItemType(iteratedType, iteratedValue.getResolveScope());
     }
 
-    Ref<NullabilityAnnotationInfo> result = Ref.create(null);
-    InheritanceUtil.processSuperTypes(type, true, eachType -> {
-      result.set(getTypeOwnNullability(eachType));
-      return result.get() == null &&
-          (!(type instanceof PsiClassType) || PsiUtil.resolveClassInClassTypeOnly(type) instanceof PsiTypeParameter);
-    });
-    return result.get();
-  }
-
-  @Nullable
-  private static NullabilityAnnotationInfo getTypeOwnNullability(PsiType eachType) {
-    for (PsiAnnotation annotation : eachType.getAnnotations()) {
-      String qualifiedName = annotation.getQualifiedName();
-      NullableNotNullManager nnn = NullableNotNullManager.getInstance(annotation.getProject());
-      if (nnn.getNullables().contains(qualifiedName) && !shouldIgnoreAnnotation(annotation)) {
-        return new NullabilityAnnotationInfo(annotation, Nullability.NULLABLE, false);
-      }
-      if (nnn.getNotNulls().contains(qualifiedName)) {
-        return new NullabilityAnnotationInfo(annotation, Nullability.NOT_NULL, false);
-      }
-    }
-    if (eachType instanceof PsiClassType) {
-      PsiElement context = ((PsiClassType) eachType).getPsiContext();
-      if (context != null) {
-        return NullableNotNullManager.getInstance(context.getProject()).findDefaultTypeUseNullability(context);
-      }
+    public static @NotNull Nullability getTypeNullability(@Nullable PsiType type) {
+        if (type == null) return Nullability.UNKNOWN;
+        return type.getNullability().nullability();
     }
-    return null;
-  }
 
-  private static boolean shouldIgnoreAnnotation(PsiAnnotation annotation) {
-    PsiClass containingClass = ClassUtils.getContainingClass(annotation);
-    if (containingClass == null) {
-      return false;
-    }
-    String qualifiedName = containingClass.getQualifiedName();
-    // We deliberately ignore nullability annotations on Guava functional interfaces to avoid noise warnings
-    // See IDEA-170548 for details
-    return "com.google.common.base.Predicate".equals(qualifiedName) || "com.google.common.base.Function".equals(qualifiedName);
-  }
-
-  /**
-   * Returns the nullability of functional expression parameter
-   *
-   * @param function functional expression
-   * @param index    parameter index
-   * @return nullability, defined by SAM parameter annotations or known otherwise
-   */
-  public static Nullability getFunctionalParameterNullability(PsiFunctionalExpression function, int index) {
-    Nullability nullability = inferLambdaParameterNullability(function, index);
-    if (nullability != Nullability.UNKNOWN) {
-      return nullability;
-    }
-    PsiClassType type = ObjectUtil.tryCast(LambdaUtil.getFunctionalInterfaceType(function, true), PsiClassType.class);
-    PsiMethod sam = LambdaUtil.getFunctionalInterfaceMethod(type);
-    if (sam != null) {
-      PsiParameter parameter = sam.getParameterList().getParameter(index);
-      if (parameter != null) {
-        nullability = getElementNullability(null, parameter);
-        if (nullability != Nullability.UNKNOWN) {
-          return nullability;
-        }
-        PsiType parameterType = type.resolveGenerics().getSubstitutor().substitute(parameter.getType());
-        return getTypeNullability(GenericsUtil.eliminateWildcards(parameterType, false, true));
-      }
-    }
-    return Nullability.UNKNOWN;
-  }
-
-  private static Nullability inferLambdaParameterNullability(PsiFunctionalExpression lambda, int parameterIndex) {
-    PsiElement expression = lambda;
-    PsiElement expressionParent = lambda.getParent();
-    while (expressionParent instanceof PsiConditionalExpression || expressionParent instanceof PsiParenthesizedExpression) {
-      expression = expressionParent;
-      expressionParent = expressionParent.getParent();
-    }
-    if (expressionParent instanceof PsiExpressionList) {
-      PsiExpressionList list = (PsiExpressionList) expressionParent;
-      PsiElement listParent = list.getParent();
-      if (listParent instanceof PsiMethodCallExpression) {
-        PsiMethod method = ((PsiMethodCallExpression) listParent).resolveMethod();
-        if (method != null) {
-          int expressionIndex = ArrayUtil.find(list.getExpressions(), expression);
-          return getLambdaParameterNullability(method, expressionIndex, parameterIndex);
+    @Nullable
+    public static NullabilityAnnotationInfo getTypeNullabilityInfo(@Nullable PsiType type) {
+        if (type == null || type instanceof PsiPrimitiveType) {
+            return null;
         }
-      }
-    }
-    return Nullability.UNKNOWN;
-  }
-
-  private static Nullability getLambdaParameterNullability(PsiMethod method, int parameterIndex, int lambdaParameterIndex) {
-    PsiClass type = method.getContainingClass();
-    if (type != null) {
-      if (JAVA_UTIL_OPTIONAL.equals(type.getQualifiedName())) {
-        String methodName = method.getName();
-        if ((methodName.equals("map") || methodName.equals("filter") || methodName.equals("ifPresent") || methodName.equals("flatMap"))
-            && parameterIndex == 0 && lambdaParameterIndex == 0) {
-          return Nullability.NOT_NULL;
-        }
-      }
-    }
-    return Nullability.UNKNOWN;
-  }
 
-  private static boolean isEnumPredefinedMethod(PsiMethod method) {
-    return CallMatcher.enumValueOf().methodMatches(method) || CallMatcher.enumValues().methodMatches(method);
-  }
+        Ref<NullabilityAnnotationInfo> result = Ref.create(null);
+        InheritanceUtil.processSuperTypes(type, true, eachType -> {
+            result.set(getTypeOwnNullability(eachType));
+            return result.get() == null &&
+                (!(type instanceof PsiClassType) || PsiUtil.resolveClassInClassTypeOnly(type) instanceof PsiTypeParameter);
+        });
+        return result.get();
+    }
 
-  public static boolean isInitializedNotNull(PsiField field) {
-    PsiClass containingClass = field.getContainingClass();
-    if (containingClass == null) {
-      return false;
+    @Nullable
+    private static NullabilityAnnotationInfo getTypeOwnNullability(PsiType eachType) {
+        for (PsiAnnotation annotation : eachType.getAnnotations()) {
+            String qualifiedName = annotation.getQualifiedName();
+            NullableNotNullManager nnn = NullableNotNullManager.getInstance(annotation.getProject());
+            if (nnn.getNullables().contains(qualifiedName) && !shouldIgnoreAnnotation(annotation)) {
+                return new NullabilityAnnotationInfo(annotation, Nullability.NULLABLE, false);
+            }
+            if (nnn.getNotNulls().contains(qualifiedName)) {
+                return new NullabilityAnnotationInfo(annotation, Nullability.NOT_NULL, false);
+            }
+        }
+        if (eachType instanceof PsiClassType) {
+            PsiElement context = ((PsiClassType) eachType).getPsiContext();
+            if (context != null) {
+                return NullableNotNullManager.getInstance(context.getProject()).findDefaultTypeUseNullability(context);
+            }
+        }
+        return null;
     }
 
-    PsiMethod[] constructors = containingClass.getConstructors();
-    if (constructors.length == 0) {
-      return false;
+    private static boolean shouldIgnoreAnnotation(PsiAnnotation annotation) {
+        PsiClass containingClass = ClassUtils.getContainingClass(annotation);
+        if (containingClass == null) {
+            return false;
+        }
+        String qualifiedName = containingClass.getQualifiedName();
+        // We deliberately ignore nullability annotations on Guava functional interfaces to avoid noise warnings
+        // See IDEA-170548 for details
+        return "com.google.common.base.Predicate".equals(qualifiedName) || "com.google.common.base.Function".equals(qualifiedName);
+    }
+
+    /**
+     * Returns the nullability of functional expression parameter
+     *
+     * @param function functional expression
+     * @param index    parameter index
+     * @return nullability, defined by SAM parameter annotations or known otherwise
+     */
+    public static Nullability getFunctionalParameterNullability(PsiFunctionalExpression function, int index) {
+        PsiClassType type = ObjectUtil.tryCast(LambdaUtil.getFunctionalInterfaceType(function, true), PsiClassType.class);
+        PsiMethod sam = LambdaUtil.getFunctionalInterfaceMethod(type);
+        if (sam != null) {
+            PsiParameter parameter = sam.getParameterList().getParameter(index);
+            if (parameter != null) {
+                PsiType parameterType = type.resolveGenerics().getSubstitutor().substitute(parameter.getType());
+                if (parameterType instanceof PsiWildcardType wildcardType) {
+                    parameterType = wildcardType.getBound();
+                }
+                if (parameterType != null) {
+                    TypeNullability typeNullability = parameterType.getNullability();
+                    if (!typeNullability.equals(TypeNullability.UNKNOWN)) {
+                        return typeNullability.nullability();
+                    }
+                }
+                return getElementNullabilityForWrite(null, parameter);
+            }
+        }
+        return Nullability.UNKNOWN;
     }
 
-    for (PsiMethod method : constructors) {
-      if (!getNotNullInitializedFields(method, containingClass).contains(field)) {
-        return false;
-      }
+    /**
+     * Returns nullability of variable when it's expected to write to it, or nullability of method
+     * when it's expected to return a value from it.
+     * For method parameter, it's expected that either the method is called (so the parameter is written by a call),
+     * or the parameter is modified inside the method, like a local variable.
+     * This method takes into account various sources of nullability information,
+     * like method annotations, type annotations, container annotations, inferred annotations, or external annotations.
+     *
+     * @param resultType concrete type of particular variable access or method call (an instantiation of generic method return type,
+     *                   or variable type), if known.
+     * @param owner      method or variable to get its nullability
+     * @return nullability of the owner; {@link Nullability#UNKNOWN} is both parameters are null.
+     */
+    public static @NotNull Nullability getElementNullabilityForWrite(@Nullable PsiType resultType, @Nullable PsiModifierListOwner owner) {
+        return getElementNullability(resultType, owner, false);
     }
-    return true;
-  }
 
-  private static Set<PsiField> getNotNullInitializedFields(final PsiMethod constructor, final PsiClass containingClass) {
-    if (!constructor.getLanguage().isKindOf(JavaLanguage.INSTANCE)) {
-      return Collections.emptySet();
+    private static boolean isEnumPredefinedMethod(PsiMethod method) {
+        return CallMatcher.enumValueOf().methodMatches(method) || CallMatcher.enumValues().methodMatches(method);
     }
 
-    final PsiCodeBlock body = constructor.getBody();
-    if (body == null) {
-      return Collections.emptySet();
+    public static boolean isInitializedNotNull(PsiField field) {
+        PsiClass containingClass = field.getContainingClass();
+        if (containingClass == null) {
+            return false;
+        }
+
+        PsiMethod[] constructors = containingClass.getConstructors();
+        if (constructors.length == 0) {
+            return false;
+        }
+
+        for (PsiMethod method : constructors) {
+            if (!getNotNullInitializedFields(method, containingClass).contains(field)) {
+                return false;
+            }
+        }
+        return true;
     }
 
-    return LanguageCachedValueUtil.getCachedValue(constructor, new CachedValueProvider<>() {
-      @Override
-      public Result<Set<PsiField>> compute() {
+    private static Set<PsiField> getNotNullInitializedFields(final PsiMethod constructor, final PsiClass containingClass) {
+        if (!constructor.getLanguage().isKindOf(JavaLanguage.INSTANCE)) {
+            return Collections.emptySet();
+        }
+
         final PsiCodeBlock body = constructor.getBody();
-        final Map<PsiField, Boolean> map = new HashMap<>();
-        final DataFlowRunner dfaRunner = new DataFlowRunner(constructor.getProject()) {
-          PsiElement currentBlock;
+        if (body == null) {
+            return Collections.emptySet();
+        }
 
-          private boolean isCallExposingNonInitializedFields(Instruction instruction) {
-            if (!(instruction instanceof MethodCallInstruction)) {
-              return false;
+        return LanguageCachedValueUtil.getCachedValue(constructor, new CachedValueProvider<>() {
+            @Override
+            public Result<Set<PsiField>> compute() {
+                final PsiCodeBlock body = constructor.getBody();
+                final Map<PsiField, Boolean> map = new HashMap<>();
+                final DataFlowRunner dfaRunner = new DataFlowRunner(constructor.getProject()) {
+                    PsiElement currentBlock;
+
+                    private boolean isCallExposingNonInitializedFields(Instruction instruction) {
+                        if (!(instruction instanceof MethodCallInstruction)) {
+                            return false;
+                        }
+
+                        PsiCall call = ((MethodCallInstruction) instruction).getCallExpression();
+                        if (call == null) {
+                            return false;
+                        }
+
+                        if (call instanceof PsiNewExpression && canAccessFields((PsiExpression) call)) {
+                            return true;
+                        }
+
+                        if (call instanceof PsiMethodCallExpression) {
+                            PsiExpression qualifier = ((PsiMethodCallExpression) call).getMethodExpression().getQualifierExpression();
+                            if (qualifier == null || canAccessFields(qualifier)) {
+                                return true;
+                            }
+                        }
+
+                        PsiExpressionList argumentList = call.getArgumentList();
+                        if (argumentList != null) {
+                            for (PsiExpression expression : argumentList.getExpressions()) {
+                                if (canAccessFields(expression)) {
+                                    return true;
+                                }
+                            }
+                        }
+
+                        return false;
+                    }
+
+                    private boolean canAccessFields(PsiExpression expression) {
+                        PsiClass type = PsiUtil.resolveClassInClassTypeOnly(expression.getType());
+                        JBIterable<PsiClass> typeContainers =
+                            JBIterable.generate(type, PsiClass::getContainingClass).takeWhile(c -> !c.hasModifierProperty(PsiModifier.STATIC));
+                        return typeContainers.contains(containingClass);
+                    }
+
+                    @Override
+                    protected List<DfaInstructionState> createInitialInstructionStates(PsiElement psiBlock,
+                                                                                       Collection<? extends DfaMemoryState> memStates,
+                                                                                       ControlFlow flow) {
+                        currentBlock = psiBlock;
+                        return super.createInitialInstructionStates(psiBlock, memStates, flow);
+                    }
+
+                    @Override
+                    protected DfaInstructionState[] acceptInstruction(InstructionVisitor visitor,
+                                                                      DfaInstructionState instructionState) {
+                        Instruction instruction = instructionState.getInstruction();
+                        if (currentBlock == body &&
+                            (isCallExposingNonInitializedFields(instruction) ||
+                                instruction instanceof ReturnInstruction && !((ReturnInstruction) instruction).isViaException())) {
+                            for (PsiField field : containingClass.getFields()) {
+                                if (!instructionState.getMemoryState().isNotNull(getFactory().getVarFactory().createVariableValue(field))) {
+                                    map.put(field, false);
+                                }
+                                else if (!map.containsKey(field)) {
+                                    map.put(field, true);
+                                }
+                            }
+                            return DfaInstructionState.EMPTY_ARRAY;
+                        }
+                        return super.acceptInstruction(visitor, instructionState);
+                    }
+                };
+                final RunnerResult rc = dfaRunner.analyzeMethod(body, new StandardInstructionVisitor());
+                Set<PsiField> notNullFields = new HashSet<>();
+                if (rc == RunnerResult.OK) {
+                    for (Map.Entry<PsiField, Boolean> entry : map.entrySet()) {
+                        if (entry.getValue()) {
+                            notNullFields.add(entry.getKey());
+                        }
+                    }
+                }
+                return Result.create(notNullFields, constructor, PsiModificationTracker.MODIFICATION_COUNT);
             }
+        });
+    }
 
-            PsiCall call = ((MethodCallInstruction) instruction).getCallExpression();
-            if (call == null) {
-              return false;
-            }
+    public static List<PsiExpression> findAllConstructorInitializers(PsiField field) {
+        final List<PsiExpression> result = Lists.newLockFreeCopyOnWriteList();
+        ContainerUtil.addIfNotNull(result, field.getInitializer());
 
-            if (call instanceof PsiNewExpression && canAccessFields((PsiExpression) call)) {
-              return true;
-            }
+        final PsiClass containingClass = field.getContainingClass();
+        if (containingClass != null && !(containingClass instanceof PsiCompiledElement)) {
+            result.addAll(getAllConstructorFieldInitializers(containingClass).get(field));
+        }
+        return result;
+    }
 
-            if (call instanceof PsiMethodCallExpression) {
-              PsiExpression qualifier = ((PsiMethodCallExpression) call).getMethodExpression().getQualifierExpression();
-              if (qualifier == null || canAccessFields(qualifier)) {
-                return true;
-              }
-            }
+    private static MultiMap<PsiField, PsiExpression> getAllConstructorFieldInitializers(final PsiClass psiClass) {
+        if (psiClass instanceof PsiCompiledElement) {
+            return MultiMap.empty();
+        }
 
-            PsiExpressionList argumentList = call.getArgumentList();
-            if (argumentList != null) {
-              for (PsiExpression expression : argumentList.getExpressions()) {
-                if (canAccessFields(expression)) {
-                  return true;
+        return LanguageCachedValueUtil.getCachedValue(psiClass, new CachedValueProvider<>() {
+            @Override
+            public Result<MultiMap<PsiField, PsiExpression>> compute() {
+                final Set<String> fieldNames = new HashSet<>();
+                for (PsiField field : psiClass.getFields()) {
+                    ContainerUtil.addIfNotNull(fieldNames, field.getName());
                 }
-              }
-            }
 
-            return false;
-          }
-
-          private boolean canAccessFields(PsiExpression expression) {
-            PsiClass type = PsiUtil.resolveClassInClassTypeOnly(expression.getType());
-            JBIterable<PsiClass> typeContainers =
-                JBIterable.generate(type, PsiClass::getContainingClass).takeWhile(c -> !c.hasModifierProperty(PsiModifier.STATIC));
-            return typeContainers.contains(containingClass);
-          }
-
-          @Override
-          protected
-          List<DfaInstructionState> createInitialInstructionStates(PsiElement psiBlock,
-                                                                   Collection<? extends DfaMemoryState> memStates,
-                                                                   ControlFlow flow) {
-            currentBlock = psiBlock;
-            return super.createInitialInstructionStates(psiBlock, memStates, flow);
-          }
-
-          @Override
-          protected DfaInstructionState[] acceptInstruction(InstructionVisitor visitor,
-                                                            DfaInstructionState instructionState) {
-            Instruction instruction = instructionState.getInstruction();
-            if (currentBlock == body &&
-                (isCallExposingNonInitializedFields(instruction) ||
-                    instruction instanceof ReturnInstruction && !((ReturnInstruction) instruction).isViaException())) {
-              for (PsiField field : containingClass.getFields()) {
-                if (!instructionState.getMemoryState().isNotNull(getFactory().getVarFactory().createVariableValue(field))) {
-                  map.put(field, false);
-                } else if (!map.containsKey(field)) {
-                  map.put(field, true);
+                final MultiMap<PsiField, PsiExpression> result = new MultiMap<>();
+                JavaRecursiveElementWalkingVisitor visitor = new JavaRecursiveElementWalkingVisitor() {
+                    @Override
+                    public void visitAssignmentExpression(PsiAssignmentExpression assignment) {
+                        super.visitAssignmentExpression(assignment);
+                        PsiExpression lExpression = assignment.getLExpression();
+                        PsiExpression rExpression = assignment.getRExpression();
+                        if (rExpression != null &&
+                            lExpression instanceof PsiReferenceExpression &&
+                            fieldNames.contains(((PsiReferenceExpression) lExpression).getReferenceName())) {
+                            PsiElement target = ((PsiReferenceExpression) lExpression).resolve();
+                            if (target instanceof PsiField && ((PsiField) target).getContainingClass() == psiClass) {
+                                result.putValue((PsiField) target, rExpression);
+                            }
+                        }
+                    }
+                };
+
+                for (PsiMethod constructor : psiClass.getConstructors()) {
+                    if (constructor.getLanguage().isKindOf(JavaLanguage.INSTANCE)) {
+                        constructor.accept(visitor);
+                    }
                 }
-              }
-              return DfaInstructionState.EMPTY_ARRAY;
-            }
-            return super.acceptInstruction(visitor, instructionState);
-          }
-        };
-        final RunnerResult rc = dfaRunner.analyzeMethod(body, new StandardInstructionVisitor());
-        Set<PsiField> notNullFields = new HashSet<>();
-        if (rc == RunnerResult.OK) {
-          for (Map.Entry<PsiField, Boolean> entry : map.entrySet()) {
-            if (entry.getValue()) {
-              notNullFields.add(entry.getKey());
-            }
-          }
-        }
-        return Result.create(notNullFields, constructor, PsiModificationTracker.MODIFICATION_COUNT);
-      }
-    });
-  }
 
-  public static List<PsiExpression> findAllConstructorInitializers(PsiField field) {
-    final List<PsiExpression> result = Lists.newLockFreeCopyOnWriteList();
-    ContainerUtil.addIfNotNull(result, field.getInitializer());
+                return Result.create(result, psiClass);
+            }
+        });
+    }
 
-    final PsiClass containingClass = field.getContainingClass();
-    if (containingClass != null && !(containingClass instanceof PsiCompiledElement)) {
-      result.addAll(getAllConstructorFieldInitializers(containingClass).get(field));
+    @Nullable
+    public static PsiElement getTopmostBlockInSameClass(PsiElement position) {
+        return JBIterable.
+            generate(position, PsiElement::getParent).
+            takeWhile(e -> !(e instanceof PsiMember || e instanceof PsiFile || e instanceof PsiLambdaExpression)).
+            filter(e -> e instanceof PsiCodeBlock || e instanceof PsiExpression && e.getParent() instanceof PsiLambdaExpression).
+            last();
+    }
+
+    public static Collection<PsiExpression> getVariableAssignmentsInFile(PsiVariable psiVariable,
+                                                                         final boolean literalsOnly,
+                                                                         final PsiElement place) {
+        Ref<Boolean> modificationRef = Ref.create(Boolean.FALSE);
+        PsiElement codeBlock = place == null ? null : getTopmostBlockInSameClass(place);
+        int placeOffset = codeBlock != null ? place.getTextRange().getStartOffset() : 0;
+        PsiFile containingFile = psiVariable.getContainingFile();
+        LocalSearchScope scope = new LocalSearchScope(new PsiElement[]{containingFile}, null, true);
+        Collection<PsiReference> references = ReferencesSearch.search(psiVariable, scope).findAll();
+        List<PsiExpression> list = ContainerUtil.mapNotNull(
+            references,
+            (Function<PsiReference, PsiExpression>) psiReference -> {
+                if (modificationRef.get()) {
+                    return null;
+                }
+                final PsiElement parent = psiReference.getElement().getParent();
+                if (parent instanceof PsiAssignmentExpression) {
+                    final PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression) parent;
+                    final IElementType operation = assignmentExpression.getOperationTokenType();
+                    if (assignmentExpression.getLExpression() == psiReference) {
+                        if (JavaTokenType.EQ.equals(operation)) {
+                            final PsiExpression rValue = assignmentExpression.getRExpression();
+                            if (!literalsOnly || allOperandsAreLiterals(rValue)) {
+                                // if there's a codeBlock omit the values assigned later
+                                if (PsiTreeUtil.isAncestor(codeBlock, parent, true)
+                                    && placeOffset < parent.getTextRange().getStartOffset()) {
+                                    return null;
+                                }
+                                return rValue;
+                            }
+                            else {
+                                modificationRef.set(Boolean.TRUE);
+                            }
+                        }
+                        else if (JavaTokenType.PLUSEQ.equals(operation)) {
+                            modificationRef.set(Boolean.TRUE);
+                        }
+                    }
+                }
+                return null;
+            });
+        if (modificationRef.get()) {
+            return Collections.emptyList();
+        }
+        PsiExpression initializer = psiVariable.getInitializer();
+        if (initializer != null && (!literalsOnly || allOperandsAreLiterals(initializer))) {
+            list = ContainerUtil.concat(list, Collections.singletonList(initializer));
+        }
+        return list;
     }
-    return result;
-  }
 
-  private static MultiMap<PsiField, PsiExpression> getAllConstructorFieldInitializers(final PsiClass psiClass) {
-    if (psiClass instanceof PsiCompiledElement) {
-      return MultiMap.empty();
+    private static boolean allOperandsAreLiterals(@Nullable final PsiExpression expression) {
+        if (expression == null) {
+            return false;
+        }
+        if (expression instanceof PsiLiteralExpression) {
+            return true;
+        }
+        if (expression instanceof PsiPolyadicExpression) {
+            Stack<PsiExpression> stack = new Stack<>();
+            stack.add(expression);
+            while (!stack.isEmpty()) {
+                PsiExpression psiExpression = stack.pop();
+                if (psiExpression instanceof PsiPolyadicExpression) {
+                    PsiPolyadicExpression binaryExpression = (PsiPolyadicExpression) psiExpression;
+                    for (PsiExpression op : binaryExpression.getOperands()) {
+                        stack.push(op);
+                    }
+                }
+                else if (!(psiExpression instanceof PsiLiteralExpression)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
     }
 
-    return LanguageCachedValueUtil.getCachedValue(psiClass, new CachedValueProvider<>() {
-      @Override
-      public Result<MultiMap<PsiField, PsiExpression>> compute() {
-        final Set<String> fieldNames = new HashSet<>();
-        for (PsiField field : psiClass.getFields()) {
-          ContainerUtil.addIfNotNull(fieldNames, field.getName());
-        }
-
-        final MultiMap<PsiField, PsiExpression> result = new MultiMap<>();
-        JavaRecursiveElementWalkingVisitor visitor = new JavaRecursiveElementWalkingVisitor() {
-          @Override
-          public void visitAssignmentExpression(PsiAssignmentExpression assignment) {
-            super.visitAssignmentExpression(assignment);
-            PsiExpression lExpression = assignment.getLExpression();
-            PsiExpression rExpression = assignment.getRExpression();
-            if (rExpression != null &&
-                lExpression instanceof PsiReferenceExpression &&
-                fieldNames.contains(((PsiReferenceExpression) lExpression).getReferenceName())) {
-              PsiElement target = ((PsiReferenceExpression) lExpression).resolve();
-              if (target instanceof PsiField && ((PsiField) target).getContainingClass() == psiClass) {
-                result.putValue((PsiField) target, rExpression);
-              }
+    /**
+     * @param method method to check
+     * @return nullability of vararg parameter component; {@link Nullability#UNKNOWN} if not specified or method is not vararg method.
+     */
+    static Nullability getVarArgComponentNullability(PsiMethod method) {
+        if (method != null) {
+            if (NON_NULL_VAR_ARG.methodMatches(method)) {
+                return Nullability.NOT_NULL;
             }
-          }
-        };
-
-        for (PsiMethod constructor : psiClass.getConstructors()) {
-          if (constructor.getLanguage().isKindOf(JavaLanguage.INSTANCE)) {
-            constructor.accept(visitor);
-          }
-        }
-
-        return Result.create(result, psiClass);
-      }
-    });
-  }
-
-  @Nullable
-  public static PsiElement getTopmostBlockInSameClass(PsiElement position) {
-    return JBIterable.
-        generate(position, PsiElement::getParent).
-        takeWhile(e -> !(e instanceof PsiMember || e instanceof PsiFile || e instanceof PsiLambdaExpression)).
-        filter(e -> e instanceof PsiCodeBlock || e instanceof PsiExpression && e.getParent() instanceof PsiLambdaExpression).
-        last();
-  }
-
-  public static Collection<PsiExpression> getVariableAssignmentsInFile(PsiVariable psiVariable,
-                                                                       final boolean literalsOnly,
-                                                                       final PsiElement place) {
-    Ref<Boolean> modificationRef = Ref.create(Boolean.FALSE);
-    PsiElement codeBlock = place == null ? null : getTopmostBlockInSameClass(place);
-    int placeOffset = codeBlock != null ? place.getTextRange().getStartOffset() : 0;
-    PsiFile containingFile = psiVariable.getContainingFile();
-    LocalSearchScope scope = new LocalSearchScope(new PsiElement[]{containingFile}, null, true);
-    Collection<PsiReference> references = ReferencesSearch.search(psiVariable, scope).findAll();
-    List<PsiExpression> list = ContainerUtil.mapNotNull(
-        references,
-        (Function<PsiReference, PsiExpression>) psiReference -> {
-          if (modificationRef.get()) {
-            return null;
-          }
-          final PsiElement parent = psiReference.getElement().getParent();
-          if (parent instanceof PsiAssignmentExpression) {
-            final PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression) parent;
-            final IElementType operation = assignmentExpression.getOperationTokenType();
-            if (assignmentExpression.getLExpression() == psiReference) {
-              if (JavaTokenType.EQ.equals(operation)) {
-                final PsiExpression rValue = assignmentExpression.getRExpression();
-                if (!literalsOnly || allOperandsAreLiterals(rValue)) {
-                  // if there's a codeBlock omit the values assigned later
-                  if (PsiTreeUtil.isAncestor(codeBlock, parent, true)
-                      && placeOffset < parent.getTextRange().getStartOffset()) {
-                    return null;
-                  }
-                  return rValue;
-                } else {
-                  modificationRef.set(Boolean.TRUE);
+            PsiParameter varArg = ArrayUtil.getLastElement(method.getParameterList().getParameters());
+            if (varArg != null) {
+                PsiType type = varArg.getType();
+                if (type instanceof PsiEllipsisType) {
+                    PsiType componentType = ((PsiEllipsisType) type).getComponentType();
+                    return getTypeNullability(componentType);
                 }
-              } else if (JavaTokenType.PLUSEQ.equals(operation)) {
-                modificationRef.set(Boolean.TRUE);
-              }
             }
-          }
-          return null;
-        });
-    if (modificationRef.get()) {
-      return Collections.emptyList();
-    }
-    PsiExpression initializer = psiVariable.getInitializer();
-    if (initializer != null && (!literalsOnly || allOperandsAreLiterals(initializer))) {
-      list = ContainerUtil.concat(list, Collections.singletonList(initializer));
+        }
+        return Nullability.UNKNOWN;
+    }
+
+    /**
+     * Try to restore type parameters based on the expression type
+     *
+     * @param expression expression which type is a supertype of the type to generify
+     * @param type       a type to generify
+     * @return a generified type, or original type if generification is not possible
+     */
+    public static PsiType tryGenerify(PsiExpression expression, PsiType type) {
+        if (!(type instanceof PsiClassType)) {
+            return type;
+        }
+        PsiClassType classType = (PsiClassType) type;
+        if (!classType.isRaw()) {
+            return classType;
+        }
+        PsiClass psiClass = classType.resolve();
+        if (psiClass == null) {
+            return classType;
+        }
+        PsiType expressionType = expression.getType();
+        if (!(expressionType instanceof PsiClassType)) {
+            return classType;
+        }
+        PsiClassType result = GenericsUtil.getExpectedGenericType(expression, psiClass, (PsiClassType) expressionType);
+        if (result.isRaw()) {
+            PsiClass aClass = result.resolve();
+            if (aClass != null) {
+                int length = aClass.getTypeParameters().length;
+                PsiWildcardType wildcard = PsiWildcardType.createUnbounded(aClass.getManager());
+                PsiType[] arguments = new PsiType[length];
+                Arrays.fill(arguments, wildcard);
+                return JavaPsiFacade.getElementFactory(aClass.getProject()).createType(aClass, arguments);
+            }
+        }
+        return result;
     }
-    return list;
-  }
 
-  private static boolean allOperandsAreLiterals(@Nullable final PsiExpression expression) {
-    if (expression == null) {
-      return false;
-    }
-    if (expression instanceof PsiLiteralExpression) {
-      return true;
-    }
-    if (expression instanceof PsiPolyadicExpression) {
-      Stack<PsiExpression> stack = new Stack<>();
-      stack.add(expression);
-      while (!stack.isEmpty()) {
-        PsiExpression psiExpression = stack.pop();
-        if (psiExpression instanceof PsiPolyadicExpression) {
-          PsiPolyadicExpression binaryExpression = (PsiPolyadicExpression) psiExpression;
-          for (PsiExpression op : binaryExpression.getOperands()) {
-            stack.push(op);
-          }
-        } else if (!(psiExpression instanceof PsiLiteralExpression)) {
-          return false;
-        }
-      }
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * @param method method to check
-   * @return nullability of vararg parameter component; {@link Nullability#UNKNOWN} if not specified or method is not vararg method.
-   */
-  static Nullability getVarArgComponentNullability(PsiMethod method) {
-    if (method != null) {
-      if (NON_NULL_VAR_ARG.methodMatches(method)) {
-        return Nullability.NOT_NULL;
-      }
-      PsiParameter varArg = ArrayUtil.getLastElement(method.getParameterList().getParameters());
-      if (varArg != null) {
-        PsiType type = varArg.getType();
-        if (type instanceof PsiEllipsisType) {
-          PsiType componentType = ((PsiEllipsisType) type).getComponentType();
-          return getTypeNullability(componentType);
-        }
-      }
-    }
-    return Nullability.UNKNOWN;
-  }
-
-  /**
-   * Try to restore type parameters based on the expression type
-   *
-   * @param expression expression which type is a supertype of the type to generify
-   * @param type       a type to generify
-   * @return a generified type, or original type if generification is not possible
-   */
-  public static PsiType tryGenerify(PsiExpression expression, PsiType type) {
-    if (!(type instanceof PsiClassType)) {
-      return type;
-    }
-    PsiClassType classType = (PsiClassType) type;
-    if (!classType.isRaw()) {
-      return classType;
-    }
-    PsiClass psiClass = classType.resolve();
-    if (psiClass == null) {
-      return classType;
-    }
-    PsiType expressionType = expression.getType();
-    if (!(expressionType instanceof PsiClassType)) {
-      return classType;
-    }
-    PsiClassType result = GenericsUtil.getExpectedGenericType(expression, psiClass, (PsiClassType) expressionType);
-    if (result.isRaw()) {
-      PsiClass aClass = result.resolve();
-      if (aClass != null) {
-        int length = aClass.getTypeParameters().length;
-        PsiWildcardType wildcard = PsiWildcardType.createUnbounded(aClass.getManager());
-        PsiType[] arguments = new PsiType[length];
-        Arrays.fill(arguments, wildcard);
-        return JavaPsiFacade.getElementFactory(aClass.getProject()).createType(aClass, arguments);
-      }
-    }
-    return result;
-  }
-
-  /**
-   * @param expr literal to create a constant type from
-   * @return a DfType that describes given literal
-   */
-  public static DfType fromLiteral(PsiLiteralExpression expr) {
-    PsiType type = expr.getType();
-    if (type == null) {
-      return DfTypes.TOP;
-    }
-    if (PsiType.NULL.equals(type)) {
-      return DfTypes.NULL;
-    }
-    Object value = expr.getValue();
-    if (value == null) {
-      return DfTypes.typedObject(type, Nullability.NOT_NULL);
+    /**
+     * @param expr literal to create a constant type from
+     * @return a DfType that describes given literal
+     */
+    public static DfType fromLiteral(PsiLiteralExpression expr) {
+        PsiType type = expr.getType();
+        if (type == null) {
+            return DfTypes.TOP;
+        }
+        if (PsiType.NULL.equals(type)) {
+            return DfTypes.NULL;
+        }
+        Object value = expr.getValue();
+        if (value == null) {
+            return DfTypes.typedObject(type, Nullability.NOT_NULL);
+        }
+        return DfTypes.constant(value, type);
     }
-    return DfTypes.constant(value, type);
-  }
 }
diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/nullable/NullabilityAnnotationWrapper.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/nullable/NullabilityAnnotationWrapper.java
new file mode 100644
index 0000000000..63590721e9
--- /dev/null
+++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/nullable/NullabilityAnnotationWrapper.java
@@ -0,0 +1,103 @@
+// Copyright 2000-2026 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
+package com.intellij.java.analysis.impl.codeInspection.nullable;
+
+import com.intellij.java.language.codeInsight.*;
+import com.intellij.java.language.psi.*;
+import com.intellij.java.language.psi.util.PsiUtil;
+import com.intellij.java.language.util.JavaTypeNullabilityUtil;
+import consulo.language.psi.PsiElement;
+import consulo.util.lang.ObjectUtil;
+import org.jetbrains.annotations.Nullable;
+import org.jspecify.annotations.NullMarked;
+
+
+/// Encapsulates information related to a nullability annotation.
+///
+@NullMarked
+public final class NullabilityAnnotationWrapper {
+    private final NullabilityAnnotationInfo info;
+
+    private NullabilityAnnotationWrapper(NullabilityAnnotationInfo info) {
+        this.info = info;
+    }
+
+    /// Constructs a NullabilityAnnotationWrapper for a given PsiAnnotation
+    ///
+    /// @return a NullabilityAnnotationWrapper instance containing nullability and annotation details,
+    ///         or null if the annotation's nullability cannot be determined
+    public static @Nullable NullabilityAnnotationWrapper from(PsiAnnotation annotation) {
+        TypeNullability typeNullability = JavaTypeNullabilityUtil.getNullabilityFromAnnotations(new PsiAnnotation[]{annotation});
+        NullabilityAnnotationInfo info = typeNullability.toNullabilityAnnotationInfo();
+        if (info == null) return null;
+        return new NullabilityAnnotationWrapper(info);
+    }
+
+    /// Evaluates whether the wrapped annotation is redundant within the scope of a container annotation
+    /// and returns that container nullability annotation info. Otherwise, returns null.
+    public @Nullable NullabilityAnnotationInfo findContainerInfoForRedundantAnnotation() {
+        PsiModifierListOwner listOwner = listOwner();
+        if (listOwner != null && targetType() != null) {
+            NullabilityAnnotationInfo info = manager().findContainerAnnotation(listOwner);
+            return isRedundantInContainerScope(info) ? info : null;
+        }
+        else {
+            PsiType type = type();
+            if (type != null) {
+                PsiElement context = type instanceof PsiClassType classType ? classType.getPsiContext() : info.getAnnotation();
+                if (context != null) {
+                    NullabilityAnnotationInfo info = manager().findDefaultTypeUseNullability(context);
+                    return isRedundantInContainerScope(info) ? info : null;
+                }
+            }
+        }
+        return null;
+    }
+
+    private boolean isRedundantInContainerScope(@Nullable NullabilityAnnotationInfo containerInfo) {
+        return containerInfo != null &&
+            !containerInfo.getAnnotation().equals(info.getAnnotation()) &&
+            containerInfo.getNullability() == info.getNullability();
+    }
+
+    /// @return modifier list owner
+    public @Nullable PsiModifierListOwner listOwner() {
+        return annotation().getOwner() instanceof PsiModifierList modifierList
+            ? ObjectUtil.tryCast(modifierList.getParent(), PsiModifierListOwner.class)
+            : null;
+    }
+
+    /// @return related type of wrapped annotation
+    public @Nullable PsiType type() {
+        return AnnotationUtil.getRelatedType(annotation());
+    }
+
+    /// @return target type of wrapped annotation
+    public @Nullable PsiType targetType() {
+        PsiModifierListOwner listOwner = listOwner();
+        return listOwner == null ? null : PsiUtil.getTypeByPsiElement(listOwner);
+    }
+
+    /// @return qualified name of wrapped annotation
+    public @Nullable String qualifiedName() {
+        return annotation().getQualifiedName();
+    }
+
+    /// @return wrapped annotation owner
+    public @Nullable PsiAnnotationOwner owner() {
+        return annotation().getOwner();
+    }
+
+    /// @return nullability represented by wrapped annotation
+    public Nullability nullability() {
+        return info.getNullability();
+    }
+
+    /// @return wrapped annotation
+    public PsiAnnotation annotation() {
+        return info.getAnnotation();
+    }
+
+    private NullableNotNullManager manager() {
+        return NullableNotNullManager.getInstance(info.getAnnotation().getProject());
+    }
+}
diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/nullable/NullableStuffInspectionBase.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/nullable/NullableStuffInspectionBase.java
index 299e99a31e..7171dbbed5 100644
--- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/nullable/NullableStuffInspectionBase.java
+++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/nullable/NullableStuffInspectionBase.java
@@ -1,30 +1,32 @@
 // Copyright 2000-2019 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.
 package com.intellij.java.analysis.impl.codeInspection.nullable;
 
+import com.intellij.java.analysis.JavaAnalysisBundle;
 import com.intellij.java.analysis.codeInspection.AbstractBaseJavaLocalInspectionTool;
+import com.intellij.java.analysis.impl.codeInsight.intention.AddAnnotationFix;
 import com.intellij.java.analysis.impl.codeInsight.intention.AddAnnotationPsiFix;
-import com.intellij.java.analysis.impl.codeInspection.AnnotateMethodFix;
 import com.intellij.java.analysis.impl.codeInspection.RemoveAnnotationQuickFix;
 import com.intellij.java.analysis.impl.codeInspection.dataFlow.DfaPsiUtil;
 import com.intellij.java.analysis.impl.codeInspection.dataFlow.instructions.MethodCallInstruction;
 import com.intellij.java.analysis.impl.psi.impl.search.JavaNullMethodArgumentUtil;
 import com.intellij.java.indexing.impl.search.JavaOverridingMethodsSearcher;
 import com.intellij.java.indexing.search.searches.OverridingMethodsSearch;
+import com.intellij.java.language.JavaFeature;
 import com.intellij.java.language.codeInsight.*;
-import com.intellij.java.language.codeInsight.daemon.impl.analysis.JavaGenericsUtil;
+import com.intellij.java.language.impl.psi.impl.PsiImplUtil;
+import com.intellij.java.language.impl.psi.util.JavaPsiRecordUtil;
 import com.intellij.java.language.psi.*;
 import com.intellij.java.language.psi.codeStyle.JavaCodeStyleManager;
 import com.intellij.java.language.psi.codeStyle.VariableKind;
 import com.intellij.java.language.psi.util.*;
-import consulo.annotation.access.RequiredReadAction;
+import com.intellij.java.language.util.JavaTypeNullabilityUtil;
+import com.siyeh.ig.psiutils.TypeUtils;
 import consulo.application.util.registry.Registry;
-import consulo.java.analysis.impl.localize.JavaInspectionsLocalize;
+import consulo.language.editor.FileModificationService;
 import consulo.language.editor.inspection.*;
 import consulo.language.editor.inspection.localize.InspectionLocalize;
-import consulo.language.psi.PsiElement;
-import consulo.language.psi.PsiElementVisitor;
-import consulo.language.psi.PsiFile;
-import consulo.language.psi.SyntaxTraverser;
+import consulo.language.editor.util.LanguageUndoUtil;
+import consulo.language.psi.*;
 import consulo.language.psi.scope.GlobalSearchScope;
 import consulo.language.psi.util.PsiTreeUtil;
 import consulo.localize.LocalizeValue;
@@ -33,60 +35,134 @@
 import consulo.project.content.GeneratedSourcesFilter;
 import consulo.util.collection.ArrayUtil;
 import consulo.util.collection.ContainerUtil;
-import consulo.util.lang.Couple;
-import consulo.util.lang.ObjectUtil;
 import consulo.util.lang.StringUtil;
 import consulo.virtualFileSystem.VirtualFile;
-import org.jspecify.annotations.Nullable;
+import one.util.streamex.StreamEx;
 import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.PropertyKey;
+import org.jspecify.annotations.Nullable;
 
 import java.util.*;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
 
-import static com.intellij.java.language.codeInsight.AnnotationUtil.CHECK_HIERARCHY;
-import static com.intellij.java.language.codeInsight.AnnotationUtil.CHECK_TYPE;
+import static com.intellij.java.language.codeInsight.AnnotationUtil.*;
 import static com.intellij.java.language.patterns.PsiJavaPatterns.psiElement;
 import static com.intellij.java.language.patterns.PsiJavaPatterns.psiMethod;
+import static consulo.util.lang.ObjectUtil.tryCast;
 
 public abstract class NullableStuffInspectionBase extends AbstractBaseJavaLocalInspectionTool<NullableStuffInspectionState> {
-    private static final Logger LOG = Logger.getInstance(NullableStuffInspectionBase.class);
+    private static Logger LOG = Logger.getInstance(NullableStuffInspectionBase.class);
 
     @Override
-    @RequiredReadAction
-    public PsiElementVisitor buildVisitorImpl(
-        final ProblemsHolder holder,
-        boolean isOnTheFly,
-        LocalInspectionToolSession session,
-        NullableStuffInspectionState state
-    ) {
+    public PsiElementVisitor buildVisitorImpl(final ProblemsHolder holder,
+                                                       final boolean isOnTheFly,
+                                                       LocalInspectionToolSession session,
+                                                       NullableStuffInspectionState state) {
         PsiFile file = holder.getFile();
-        if (!PsiUtil.isLanguageLevel5OrHigher(file) || nullabilityAnnotationsNotAvailable(file)) {
+        if (!PsiUtil.isAvailable(JavaFeature.ANNOTATIONS, file) || nullabilityAnnotationsNotAvailable(file)) {
             return PsiElementVisitor.EMPTY_VISITOR;
         }
         return new JavaElementVisitor() {
+            private NullableNotNullManager manager = NullableNotNullManager.getInstance(holder.getProject());
+            private List<String> nullables = manager.getNullables();
+            private List<String> notNulls = manager.getNotNulls();
+
             @Override
-            @RequiredReadAction
             public void visitMethod(PsiMethod method) {
-                checkNullableStuffForMethod(method, holder, isOnTheFly, state);
+                checkNullableStuffForMethod(method, holder, state);
+            }
+
+            @Override
+            public void visitClass(PsiClass aClass) {
+                if (aClass.isRecord()) {
+                    PsiMethod constructor = JavaPsiRecordUtil.findCanonicalConstructor(aClass);
+                    if (constructor instanceof SyntheticElement) {
+                        checkParameters(constructor, holder, List.of(), manager, state);
+                    }
+                }
+                checkConflictingContainerAnnotations(holder, aClass.getModifierList());
+            }
+
+            @Override
+            public void visitPackageStatement(PsiPackageStatement statement) {
+                checkConflictingContainerAnnotations(holder, statement.getAnnotationList());
+            }
+
+            @Override
+            public void visitModule(PsiJavaModule module) {
+                checkConflictingContainerAnnotations(holder, module.getModifierList());
+            }
+
+            @Override
+            public void visitNewExpression(PsiNewExpression expression) {
+                if (expression.isArrayCreation()) {
+                    return;
+                }
+                super.visitNewExpression(expression);
+                PsiJavaCodeReferenceElement ref = expression.getClassOrAnonymousClassReference();
+                if (ref == null) {
+                    return;
+                }
+                if (!(ref.resolve() instanceof PsiClass cls)) {
+                    return;
+                }
+                String qualifiedName = cls.getQualifiedName();
+                if (qualifiedName == null) {
+                    return;
+                }
+                PsiExpressionList list = expression.getArgumentList();
+                if (list == null) {
+                    return;
+                }
+                if (!(expression.getType() instanceof PsiClassType type) || type.getParameterCount() != 1) {
+                    return;
+                }
+                PsiType typeParameter = type.getParameters()[0];
+                if (!(typeParameter instanceof PsiClassType classType) ||
+                    DfaPsiUtil.getTypeNullability(typeParameter) != Nullability.NOT_NULL) {
+                    return;
+                }
+                boolean matched = switch (qualifiedName) {
+                    case "java.util.concurrent.atomic.AtomicReference" -> list.getExpressionCount() == 0;
+                    case "java.util.concurrent.atomic.AtomicReferenceArray" ->
+                        list.getExpressionCount() == 1 && PsiTypes.intType().equals(list.getExpressionTypes()[0]);
+                    case "java.lang.ThreadLocal" -> list.getExpressionCount() == 0 && expression.getAnonymousClass() == null;
+                    default -> false;
+                };
+                if (!matched) {
+                    return;
+                }
+
+                AddTypeAnnotationFix fix = null;
+                if (classType.getPsiContext() instanceof PsiJavaCodeReferenceElement typeRef &&
+                    typeRef.getParent() instanceof PsiTypeElement typeElement && typeElement.getType().equals(classType) &&
+                    typeElement.acceptsAnnotations()) {
+                    fix = new AddTypeAnnotationFix(typeElement, manager.getDefaultAnnotation(Nullability.NULLABLE, expression), notNulls);
+                }
+                holder.problem(expression,
+                        JavaAnalysisBundle.message("inspection.nullable.problems.constructor.not.compatible.non.null.type.argument"))
+                    .maybeFix(fix)
+                    .register();
             }
 
             @Override
-            @RequiredReadAction
             public void visitMethodReferenceExpression(PsiMethodReferenceExpression expression) {
                 checkMethodReference(expression, holder, state);
 
                 JavaResolveResult result = expression.advancedResolve(false);
                 PsiElement target = result.getElement();
-                if (target instanceof PsiMethod method) {
-                    checkCollectionNullityOnAssignment(
-                        expression,
+                if (target instanceof PsiMethod) {
+                    checkNestedGenericClasses(holder, expression,
                         LambdaUtil.getFunctionalInterfaceReturnType(expression),
-                        result.getSubstitutor().substitute(method.getReturnType())
-                    );
+                        result.getSubstitutor().substitute(((PsiMethod) target).getReturnType()),
+                        ConflictNestedTypeProblem.ASSIGNMENT_NESTED_TYPE_PROBLEM,
+                        state);
                 }
             }
 
             @Override
-            @RequiredReadAction
             public void visitField(PsiField field) {
                 PsiType type = field.getType();
                 Annotated annotated = check(field, holder, type);
@@ -94,18 +170,70 @@ public void visitField(PsiField field) {
                     return;
                 }
                 Project project = holder.getProject();
-                NullableNotNullManager manager = NullableNotNullManager.getInstance(project);
                 if (annotated.isDeclaredNotNull ^ annotated.isDeclaredNullable) {
-                    String anno = annotated.isDeclaredNotNull ? manager.getDefaultNotNull() : manager.getDefaultNullable();
-                    List<String> annoToRemove = annotated.isDeclaredNotNull ? manager.getNullables() : manager.getNotNulls();
-
-                    if (!checkNonStandardAnnotations(field, annotated, manager, anno, holder)) {
-                        return;
-                    }
+                    String anno =
+                        manager.getDefaultAnnotation(annotated.isDeclaredNotNull ? Nullability.NOT_NULL : Nullability.NULLABLE, field);
+                    List<String> annoToRemove = annotated.isDeclaredNotNull ? nullables : notNulls;
 
                     checkAccessors(field, annotated, project, manager, anno, annoToRemove, holder, state);
 
-                    checkConstructorParameters(field, annotated, manager, anno, annoToRemove, holder, state);
+                    checkConstructorParameters(field, annotated, anno, annoToRemove, holder, state);
+                }
+                PsiExpression initializer = field.getInitializer();
+                PsiElement identifyingElement = field.getIdentifyingElement();
+                if (initializer != null && identifyingElement != null) {
+                    checkNestedGenericClasses(holder, identifyingElement, field.getType(), initializer.getType(),
+                        ConflictNestedTypeProblem.ASSIGNMENT_NESTED_TYPE_PROBLEM, state);
+                }
+            }
+
+            @Override
+            public void visitMethodCallExpression(PsiMethodCallExpression call) {
+                super.visitMethodCallExpression(call);
+                PsiReferenceParameterList parameterList = call.getMethodExpression().getParameterList();
+                if (parameterList == null) {
+                    return;
+                }
+                PsiType[] parameterization = parameterList.getTypeArguments();
+                if (parameterization.length == 0) {
+                    return;
+                }
+                PsiMethod method = call.resolveMethod();
+                if (method == null) {
+                    return;
+                }
+                PsiTypeParameter[] typeParameters = method.getTypeParameters();
+                if (typeParameters.length != parameterization.length) {
+                    return;
+                }
+                for (int i = 0; i < typeParameters.length; i++) {
+                    PsiTypeParameter typeParameter = typeParameters[i];
+                    PsiType instance = parameterization[i];
+                    TypeNullability nullability = TypeNullability.ofTypeParameter(typeParameter);
+                    if (nullability.nullability() != Nullability.NOT_NULL) {
+                        continue;
+                    }
+                    TypeNullability instanceNullability = instance.getNullability();
+                    if (instanceNullability.nullability() == Nullability.NOT_NULL) {
+                        continue;
+                    }
+                    NullabilitySource source = instanceNullability.source();
+                    if (source instanceof NullabilitySource.ExplicitAnnotation explicit) {
+                        PsiAnnotation anchor = explicit.annotation();
+                        PsiJavaCodeReferenceElement ref = anchor.getNameReferenceElement();
+                        if (ref != null) {
+                            reportProblem(holder, anchor, "inspection.nullable.problems.nullable.instantiation.of.notnull",
+                                typeParameter.getName(), ref.getReferenceName());
+                        }
+                    }
+                    else if (source instanceof NullabilitySource.ContainerAnnotation container) {
+                        PsiElement anchor = parameterList.getTypeParameterElements()[i];
+                        PsiJavaCodeReferenceElement ref = container.annotation().getNameReferenceElement();
+                        if (ref != null) {
+                            reportProblem(holder, anchor, "inspection.nullable.problems.nullable.instantiation.of.notnull.container",
+                                typeParameter.getName(), ref.getReferenceName());
+                        }
+                    }
                 }
             }
 
@@ -115,63 +243,171 @@ public void visitParameter(PsiParameter parameter) {
             }
 
             @Override
-            public void visitTypeElement(PsiTypeElement type) {
-                NullableNotNullManager manager = NullableNotNullManager.getInstance(type.getProject());
-                List<PsiAnnotation> annotations = getExclusiveAnnotations(type);
-
-                checkType(
-                    null,
-                    holder,
-                    type.getType(),
-                    ContainerUtil.find(annotations, a -> manager.getNotNulls().contains(a.getQualifiedName())),
-                    ContainerUtil.find(annotations, a -> manager.getNullables().contains(a.getQualifiedName()))
-                );
+            public void visitAnnotation(PsiAnnotation annotation) {
+                NullabilityAnnotationWrapper wrapper = NullabilityAnnotationWrapper.from(annotation);
+                if (wrapper == null) {
+                    return;
+                }
+                PsiType targetType = wrapper.targetType();
+                PsiType type = wrapper.type();
+                PsiModifierListOwner listOwner = wrapper.listOwner();
+                checkRedundantInContainerScope(wrapper, state);
+                if (type != null &&
+                    wrapper.nullability() == Nullability.NOT_NULL &&
+                    PsiUtil.resolveClassInClassTypeOnly(type) instanceof PsiTypeParameter) {
+                    PsiType notAnnotated = type.annotate(TypeAnnotationProvider.EMPTY);
+                    TypeNullability notAnnotatedNullability = notAnnotated.getNullability();
+                    if (notAnnotatedNullability.nullability() == Nullability.NOT_NULL &&
+                        notAnnotatedNullability.source() instanceof NullabilitySource.ExtendsBound) {
+                        reportProblem(holder, annotation,
+                            new RemoveAnnotationQuickFix(annotation, null),
+                            "inspection.nullable.problems.redundant.annotation.inherited.notnull");
+                    }
+                }
+                if (type instanceof PsiPrimitiveType) {
+                    LocalQuickFix additionalFix = null;
+                    if (targetType instanceof PsiArrayType && !targetType.hasAnnotations()) {
+                        additionalFix = new MoveAnnotationToArrayFix();
+                    }
+                    reportIncorrectLocation(holder, annotation, listOwner, "inspection.nullable.problems.primitive.type.annotation", LocalQuickFix.notNullElements(additionalFix));
+                }
+                if (type instanceof PsiClassType classType) {
+                    PsiElement context = classType.getPsiContext();
+                    // outer type/package
+                    if (context instanceof PsiJavaCodeReferenceElement outerCtx) {
+                        PsiElement parent = context.getParent();
+                        if (parent instanceof PsiJavaCodeReferenceElement) {
+                            if (outerCtx.resolve() instanceof PsiPackage) {
+                                ModCommandAction action = new MoveAnnotationOnStaticMemberQualifyingTypeFix(annotation);
+                                reportIncorrectLocation(holder, annotation, listOwner, "inspection.nullable.problems.applied.to.package",
+                                    LocalQuickFix.from(action));
+                            }
+                            else {
+                                // If outer is qualifier of static member then don't report problem as it is already reported
+                                // as ANNOTATION_NOT_ALLOWED_STATIC which contains exactly the same fix "Move annotation".
+                                if (!PsiImplUtil.isTypeQualifierOfStaticMember(outerCtx)) {
+                                    ModCommandAction action = new MoveAnnotationOnStaticMemberQualifyingTypeFix(annotation);
+                                    reportIncorrectLocation(holder, annotation, listOwner, "inspection.nullable.problems.outer.type",
+                                        LocalQuickFix.from(action));
+                                }
+                            }
+                        }
+                        if (parent instanceof PsiReferenceList) {
+                            PsiElement firstChild = parent.getFirstChild();
+                            if ((PsiUtil.isJavaToken(firstChild, JavaTokenType.EXTENDS_KEYWORD) ||
+                                PsiUtil.isJavaToken(firstChild, JavaTokenType.IMPLEMENTS_KEYWORD)) &&
+                                !(parent.getParent() instanceof PsiTypeParameter)) {
+                                reportIncorrectLocation(holder, annotation, listOwner, "inspection.nullable.problems.at.reference.list");
+                            }
+                            if (PsiUtil.isJavaToken(firstChild, JavaTokenType.THROWS_KEYWORD)) {
+                                reportIncorrectLocation(holder, annotation, listOwner, "inspection.nullable.problems.at.throws");
+                            }
+                        }
+                    }
+                }
+                if (type instanceof PsiArrayType && annotation.getParent() instanceof PsiTypeElement parent &&
+                    parent.getType().equals(type) && !manager.canAnnotateLocals(wrapper.qualifiedName())) {
+                    checkIllegalLocalAnnotation(annotation, parent.getParent(), state);
+                }
+                if (listOwner instanceof PsiMethod method && method.isConstructor()) {
+                    reportIncorrectLocation(holder, annotation, listOwner, "inspection.nullable.problems.at.constructor");
+                }
+                if (listOwner instanceof PsiClass && AnnotationTargetUtil.findAnnotationTarget(annotation, PsiAnnotation.TargetType.TYPE) == null) {
+                    reportIncorrectLocation(holder, annotation, listOwner, "inspection.nullable.problems.at.class");
+                }
+                if (listOwner instanceof PsiEnumConstant) {
+                    reportIncorrectLocation(holder, annotation, listOwner, "inspection.nullable.problems.at.enum.constant");
+                }
+                if (!manager.canAnnotateLocals(wrapper.qualifiedName()) && !(targetType instanceof PsiArrayType)) {
+                    checkIllegalLocalAnnotation(annotation, listOwner, state);
+                }
+                if (type instanceof PsiWildcardType && manager.isTypeUseAnnotationLocationRestricted(wrapper.qualifiedName())) {
+                    reportIncorrectLocation(holder, annotation, listOwner, "inspection.nullable.problems.at.wildcard");
+                }
+                if (wrapper.owner() instanceof PsiTypeParameter && manager.isTypeUseAnnotationLocationRestricted(wrapper.qualifiedName())) {
+                    reportIncorrectLocation(holder, annotation, listOwner, "inspection.nullable.problems.at.type.parameter");
+                }
+                if (listOwner instanceof PsiReceiverParameter && wrapper.nullability() != Nullability.NOT_NULL) {
+                    reportIncorrectLocation(holder, annotation, listOwner, "inspection.nullable.problems.receiver.annotation");
+                }
+                checkOppositeAnnotationConflict(annotation, wrapper.nullability());
+                if (NOT_NULL.equals(wrapper.qualifiedName())) {
+                    PsiAnnotationMemberValue value = annotation.findDeclaredAttributeValue("exception");
+                    if (value instanceof PsiClassObjectAccessExpression classObjectAccessExpression) {
+                        PsiClass psiClass = PsiUtil.resolveClassInClassTypeOnly(classObjectAccessExpression.getOperand().getType());
+                        if (psiClass != null && !hasStringConstructor(psiClass)) {
+                            reportProblem(holder, value, "custom.exception.class.should.have.a.constructor");
+                        }
+                    }
+                }
             }
 
-            private List<PsiAnnotation> getExclusiveAnnotations(PsiTypeElement type) {
-                List<PsiAnnotation> annotations = ContainerUtil.newArrayList(type.getAnnotations());
-                PsiTypeElement topMost = Objects.requireNonNull(SyntaxTraverser.psiApi().parents(type).filter(PsiTypeElement.class).last());
-                PsiElement parent = topMost.getParent();
-                if (parent instanceof PsiModifierListOwner && type.getType().equals(topMost.getType().getDeepComponentType())) {
-                    PsiModifierList modifierList = ((PsiModifierListOwner)parent).getModifierList();
-                    if (modifierList != null) {
-                        PsiAnnotation.TargetType[] targets =
-                            ArrayUtil.remove(AnnotationTargetUtil.getTargetsForLocation(modifierList), PsiAnnotation.TargetType.TYPE_USE);
-                        annotations.addAll(ContainerUtil.filter(
-                            modifierList.getAnnotations(),
-                            a -> AnnotationTargetUtil.isTypeAnnotation(a)
-                                && AnnotationTargetUtil.findAnnotationTarget(a, targets) == null
-                        ));
+            private void checkRedundantInContainerScope(NullabilityAnnotationWrapper wrapper, NullableStuffInspectionState state) {
+                if (state.REPORT_REDUNDANT_NULLABILITY_ANNOTATION_IN_THE_SCOPE_OF_ANNOTATED_CONTAINER) {
+                    NullabilityAnnotationInfo containerInfo = wrapper.findContainerInfoForRedundantAnnotation();
+                    if (containerInfo != null) {
+                        if (containerInfo.getNullability() == Nullability.NOT_NULL && manager.isNonNullUsedForInstrumentation(wrapper.annotation())) {
+                            return;
+                        }
+                        reportRedundantInContainerScope(wrapper.annotation(), containerInfo);
                     }
                 }
-                return annotations;
             }
 
-            @Override
-            public void visitAnnotation(PsiAnnotation annotation) {
-                if (!AnnotationUtil.NOT_NULL.equals(annotation.getQualifiedName())) {
+            private void reportRedundantInContainerScope(PsiAnnotation annotation, NullabilityAnnotationInfo containerInfo) {
+                PsiJavaCodeReferenceElement containerName = containerInfo.getAnnotation().getNameReferenceElement();
+                if (containerName != null) {
+                    LocalQuickFix updateOptionFix = LocalQuickFix.from(
+                        new UpdateInspectionOptionFix(NullableStuffInspectionBase.this,
+                            "REPORT_REDUNDANT_NULLABILITY_ANNOTATION_IN_THE_SCOPE_OF_ANNOTATED_CONTAINER",
+                            JavaAnalysisBundle.message("inspection.nullable.problems.turn.off.redundant.annotation.under.container"),
+                            false));
+                    reportProblem(holder, annotation,
+                        LocalQuickFix.notNullElements(new RemoveAnnotationQuickFix(annotation, null), updateOptionFix),
+                        "inspection.nullable.problems.redundant.annotation.under.container", containerName.getReferenceName());
+                }
+            }
+
+            private void checkIllegalLocalAnnotation(PsiAnnotation annotation, @Nullable PsiElement owner, NullableStuffInspectionState state) {
+                if (!state.REPORT_NULLABILITY_ANNOTATION_ON_LOCALS) {
                     return;
                 }
+                if (owner instanceof PsiLocalVariable ||
+                    owner instanceof PsiParameter parameter &&
+                        parameter.getDeclarationScope() instanceof PsiCatchSection) {
+                    reportIncorrectLocation(holder, annotation, (PsiVariable) owner, "inspection.nullable.problems.at.local.variable");
+                }
+            }
 
-                PsiAnnotationMemberValue value = annotation.findDeclaredAttributeValue("exception");
-                if (value instanceof PsiClassObjectAccessExpression classObjectAccessExpression) {
-                    PsiClass psiClass = PsiUtil.resolveClassInClassTypeOnly(classObjectAccessExpression.getOperand().getType());
-                    if (psiClass != null && !hasStringConstructor(psiClass)) {
-                        holder.newProblem(LocalizeValue.localizeTODO(
-                                "Custom exception class should have a constructor with a single message parameter of String type"
-                            ))
-                            .range(value)
-                            .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-                            .create();
-                    }
+            private void checkOppositeAnnotationConflict(PsiAnnotation annotation, Nullability nullability) {
+                PsiAnnotationOwner owner = annotation.getOwner();
+                if (owner == null) {
+                    return;
+                }
+                PsiModifierListOwner listOwner = owner instanceof PsiModifierList modifierList
+                    ? tryCast(modifierList.getParent(), PsiModifierListOwner.class)
+                    : null;
+                Predicate<PsiAnnotation> filter = anno ->
+                    anno != annotation && manager.getAnnotationNullability(anno.getQualifiedName()).filter(n -> n != nullability).isPresent();
+                PsiAnnotation oppositeAnno = ContainerUtil.find(owner.getAnnotations(), filter);
+                if (oppositeAnno == null && listOwner != null) {
+                    NullabilityAnnotationInfo result = manager.findNullabilityAnnotationInfo(
+                        listOwner, ContainerUtil.filter(Nullability.values(), n -> n != nullability));
+                    oppositeAnno = result == null || result.isContainer() ? null : result.getAnnotation();
+                }
+                if (oppositeAnno != null &&
+                    Objects.equals(getRelatedType(annotation), getRelatedType(oppositeAnno))) {
+                    reportProblem(holder, annotation, new RemoveAnnotationQuickFix(annotation, listOwner),
+                        "inspection.nullable.problems.Nullable.NotNull.conflict",
+                        getPresentableAnnoName(annotation), getPresentableAnnoName(oppositeAnno));
                 }
             }
 
-            private boolean hasStringConstructor(PsiClass aClass) {
+            private static boolean hasStringConstructor(PsiClass aClass) {
                 for (PsiMethod method : aClass.getConstructors()) {
                     PsiParameterList list = method.getParameterList();
                     if (list.getParametersCount() == 1 &&
-                        list.getParameters()[0].getType().equalsToText(CommonClassNames.JAVA_LANG_STRING)) {
+                        Objects.requireNonNull(list.getParameter(0)).getType().equalsToText(CommonClassNames.JAVA_LANG_STRING)) {
                         return true;
                     }
                 }
@@ -179,66 +415,93 @@ private boolean hasStringConstructor(PsiClass aClass) {
             }
 
             @Override
-            @RequiredReadAction
             public void visitReferenceElement(PsiJavaCodeReferenceElement reference) {
                 super.visitReferenceElement(reference);
 
                 checkNullableNotNullInstantiationConflict(reference);
 
                 PsiElement list = reference.getParent();
-                PsiElement psiClassElem = list instanceof PsiReferenceList ? list.getParent() : null;
-                PsiElement intf = reference.resolve();
-                if (psiClassElem instanceof PsiClass psiClass && list == psiClass.getImplementsList() &&
-                    intf instanceof PsiClass intfClass && intfClass.isInterface()) {
-                    String error = checkIndirectInheritance(psiClass, intfClass, state);
+                PsiElement parent = list instanceof PsiReferenceList ? list.getParent() : null;
+                if (parent instanceof PsiClass psiClass && list == psiClass.getImplementsList() &&
+                    reference.resolve() instanceof PsiClass intf && intf.isInterface()) {
+                    String error = checkIndirectInheritance(psiClass, intf);
                     if (error != null) {
                         holder.registerProblem(reference, error);
                     }
                 }
             }
 
-            @RequiredReadAction
             private void checkNullableNotNullInstantiationConflict(PsiJavaCodeReferenceElement reference) {
                 PsiElement element = reference.resolve();
-                if (element instanceof PsiClass psiClass) {
-                    PsiTypeParameter[] typeParameters = psiClass.getTypeParameters();
+                if (element instanceof PsiClass) {
+                    PsiTypeParameter[] typeParameters = ((PsiClass) element).getTypeParameters();
                     PsiTypeElement[] typeArguments = getReferenceTypeArguments(reference);
-                    if (typeParameters.length > 0 && typeParameters.length == typeArguments.length
-                        && !(typeArguments[0].getType() instanceof PsiDiamondType)) {
+                    if (typeParameters.length > 0 && typeParameters.length == typeArguments.length && !(typeArguments[0].getType() instanceof PsiDiamondType)) {
                         for (int i = 0; i < typeParameters.length; i++) {
-                            if (DfaPsiUtil.getTypeNullability(JavaPsiFacade.getElementFactory(element.getProject())
-                                .createType(typeParameters[i])) == Nullability.NOT_NULL
-                                && DfaPsiUtil.getTypeNullability(typeArguments[i].getType()) != Nullability.NOT_NULL) {
-                                holder.newProblem(LocalizeValue.localizeTODO("Non-null type argument is expected"))
-                                    .range(typeArguments[i])
-                                    .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-                                    .create();
+                            PsiTypeElement typeArgument = typeArguments[i];
+                            Project project = element.getProject();
+                            PsiType type = typeArgument.getType();
+                            if (TypeNullability.ofTypeParameter(typeParameters[i]).nullability() != Nullability.NOT_NULL) {
+                                continue;
+                            }
+                            TypeNullability nullability = type.getNullability();
+                            Nullability typeNullability = nullability.nullability();
+                            if (typeNullability != Nullability.NOT_NULL &&
+                                !(typeNullability == Nullability.UNKNOWN && type instanceof PsiWildcardType wildcardType && !wildcardType.isExtends())) {
+                                String annotationToAdd = manager.getDefaultAnnotation(Nullability.NOT_NULL, reference);
+                                PsiClass annotationClass = JavaPsiFacade.getInstance(project).findClass(annotationToAdd, element.getResolveScope());
+                                List<LocalQuickFix> fixes = new ArrayList<>();
+                                if (annotationClass != null &&
+                                    AnnotationTargetUtil.findAnnotationTarget(annotationClass, PsiAnnotation.TargetType.TYPE_USE) != null) {
+                                    fixes.add(LocalQuickFix.from(new AddTypeAnnotationFix(typeArgument, annotationToAdd, manager.getNullables())));
+                                }
+                                fixes.add(LocalQuickFix.from(createAnnotateAsNullMarkedFix(typeArgument, manager.getNullables())));
+                                ProblemHighlightType level =
+                                    nullability == TypeNullability.UNKNOWN && !state.REPORT_NOT_ANNOTATED_INSTANTIATION_NOT_NULL_TYPE ?
+                                        ProblemHighlightType.INFORMATION :
+                                        ProblemHighlightType.GENERIC_ERROR_OR_WARNING;
+                                if (!isOnTheFly && level == ProblemHighlightType.INFORMATION) {
+                                    continue;
+                                }
+                                holder.registerProblem(typeArgument,
+                                    JavaAnalysisBundle.message("non.null.type.argument.is.expected"),
+                                    level,
+                                    fixes.toArray(LocalQuickFix.EMPTY_ARRAY));
                             }
                         }
                     }
                 }
             }
 
-            private PsiTypeElement[] getReferenceTypeArguments(PsiJavaCodeReferenceElement reference) {
+            private static PsiTypeElement[] getReferenceTypeArguments(PsiJavaCodeReferenceElement reference) {
                 PsiReferenceParameterList typeArgList = reference.getParameterList();
                 return typeArgList == null ? PsiTypeElement.EMPTY_ARRAY : typeArgList.getTypeParameterElements();
             }
 
             @Override
             public void visitAssignmentExpression(PsiAssignmentExpression expression) {
-                checkCollectionNullityOnAssignment(
-                    expression.getOperationSign(),
+                PsiExpression rExpression = expression.getRExpression();
+                if (rExpression == null) {
+                    return;
+                }
+                checkNestedGenericClasses(holder, expression.getOperationSign(),
                     expression.getLExpression().getType(),
-                    expression.getRExpression()
-                );
+                    rExpression.getType(),
+                    ConflictNestedTypeProblem.ASSIGNMENT_NESTED_TYPE_PROBLEM, state);
             }
 
             @Override
             public void visitLocalVariable(PsiLocalVariable variable) {
                 PsiIdentifier identifier = variable.getNameIdentifier();
-                if (identifier != null) {
-                    checkCollectionNullityOnAssignment(identifier, variable.getType(), variable.getInitializer());
+                if (identifier == null) {
+                    return;
                 }
+                PsiExpression initializer = variable.getInitializer();
+                if (initializer == null) {
+                    return;
+                }
+                checkNestedGenericClasses(holder, identifier, variable.getType(), initializer.getType(),
+                    ConflictNestedTypeProblem.ASSIGNMENT_NESTED_TYPE_PROBLEM, state);
             }
 
             @Override
@@ -247,15 +510,23 @@ public void visitReturnStatement(PsiReturnStatement statement) {
                 if (returnValue == null) {
                     return;
                 }
-
-                checkCollectionNullityOnAssignment(statement.getReturnValue(), PsiTypesUtil.getMethodReturnType(statement), returnValue);
+                checkNestedGenericClasses(holder, returnValue,
+                    PsiTypesUtil.getMethodReturnType(statement), returnValue.getType(),
+                    ConflictNestedTypeProblem.RETURN_NESTED_TYPE_PROBLEM, state);
             }
 
             @Override
             public void visitLambdaExpression(PsiLambdaExpression lambda) {
                 super.visitLambdaExpression(lambda);
-                if (lambda.getBody() instanceof PsiExpression body) {
-                    checkCollectionNullityOnAssignment(body, LambdaUtil.getFunctionalInterfaceReturnType(lambda), body);
+                PsiElement body = lambda.getBody();
+                if (body instanceof PsiExpression psiExpression) {
+                    checkNestedGenericClasses(holder,
+                        body,
+                        LambdaUtil.getFunctionalInterfaceReturnType(lambda),
+                        psiExpression.getType(),
+                        ConflictNestedTypeProblem.RETURN_NESTED_TYPE_PROBLEM,
+                        state
+                    );
                 }
             }
 
@@ -263,7 +534,7 @@ public void visitLambdaExpression(PsiLambdaExpression lambda) {
             public void visitCallExpression(PsiCallExpression callExpression) {
                 PsiExpressionList argList = callExpression.getArgumentList();
                 JavaResolveResult result = callExpression.resolveMethodGenerics();
-                PsiMethod method = (PsiMethod)result.getElement();
+                PsiMethod method = (PsiMethod) result.getElement();
                 if (method == null || argList == null) {
                     return;
                 }
@@ -275,85 +546,93 @@ public void visitCallExpression(PsiCallExpression callExpression) {
                     PsiExpression argument = arguments[i];
                     if (i < parameters.length &&
                         (i < parameters.length - 1 || !MethodCallInstruction.isVarArgCall(method, substitutor, arguments, parameters))) {
-                        checkCollectionNullityOnAssignment(argument, substitutor.substitute(parameters[i].getType()), argument);
+                        PsiType expectedType = substitutor.substitute(parameters[i].getType());
+                        checkNestedGenericClasses(holder, argument, expectedType, argument.getType(),
+                            ConflictNestedTypeProblem.ASSIGNMENT_NESTED_TYPE_PROBLEM, state);
                     }
                 }
             }
+        };
+    }
 
-            private void checkCollectionNullityOnAssignment(
-                PsiElement errorElement,
-                @Nullable PsiType expectedType,
-                @Nullable PsiExpression assignedExpression
-            ) {
-                if (assignedExpression == null) {
-                    return;
-                }
+    private boolean checkNestedGenericClasses(ProblemsHolder holder,
+                                              PsiElement errorElement,
+                                              @Nullable PsiType expectedType,
+                                              @Nullable PsiType actualType,
+                                              ConflictNestedTypeProblem problem,
+                                              NullableStuffInspectionState state) {
+        if (expectedType == null || actualType == null) {
+            return false;
+        }
+        JavaTypeNullabilityUtil.NullabilityConflictContext
+            context = JavaTypeNullabilityUtil.getNullabilityConflictInAssignment(expectedType, actualType,
+            state.REPORT_NOT_NULL_TO_NULLABLE_CONFLICTS_IN_ASSIGNMENTS);
+        JavaTypeNullabilityUtil.NullabilityConflict conflict = context.nullabilityConflict();
+        String messageKey = switch (conflict) {
+            case UNKNOWN -> null;
+            case NOT_NULL_TO_NULL -> problem.notNullToNullProblem();
+            case NULL_TO_NOT_NULL -> problem.nullToNotNullProblem();
+            case COMPLEX -> problem.complexProblem();
+        };
 
-                checkCollectionNullityOnAssignment(errorElement, expectedType, assignedExpression.getType());
-            }
+        if (messageKey == null) {
+            return false;
+        }
 
-            private void checkCollectionNullityOnAssignment(
-                PsiElement errorElement,
-                @Nullable PsiType expectedType,
-                @Nullable PsiType assignedType
-            ) {
-                if (isNullableNotNullCollectionConflict(expectedType, assignedType, new HashSet<>())) {
-                    holder.newProblem(LocalizeValue.localizeTODO(
-                            "Assigning a collection of nullable elements into a collection of non-null elements"
-                        ))
-                        .range(errorElement)
-                        .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-                        .create();
-                }
-            }
+        reportProblem(holder, errorElement, LocalQuickFix.EMPTY_ARRAY,
+            messageKey, new Object[]{""},
+            messageKey, new Object[]{NullableStuffInspectionUtil.getNullabilityConflictPresentation(context)});
+        return true;
+    }
 
-            private boolean isNullableNotNullCollectionConflict(
-                @Nullable PsiType expectedType,
-                @Nullable PsiType assignedType,
-                Set<? super Couple<PsiType>> visited
-            ) {
-                if (!visited.add(Couple.of(expectedType, assignedType))) {
-                    return false;
-                }
+    private void checkConflictingContainerAnnotations(ProblemsHolder holder, @Nullable PsiModifierList list) {
+        if (list == null || !list.hasAnnotations()) {
+            return;
+        }
+        NullableNotNullManager manager = NullableNotNullManager.getInstance(holder.getProject());
+        List<PsiAnnotation> conflictingAnnotations = manager.getConflictingContainerAnnotations(list);
+        if (!conflictingAnnotations.isEmpty()) {
+            for (PsiAnnotation annotation : conflictingAnnotations) {
+                reportProblem(holder, annotation, "conflicting.nullability.annotations");
+            }
+        }
+    }
 
-                GlobalSearchScope scope = holder.getFile().getResolveScope();
-                if (isNullityConflict(
-                    JavaGenericsUtil.getCollectionItemType(expectedType, scope),
-                    JavaGenericsUtil.getCollectionItemType(assignedType, scope)
-                )) {
-                    return true;
-                }
+    private void reportProblem(ProblemsHolder holder, PsiElement anchor, String messageKey, Object... args) {
+        reportProblem(holder, anchor, LocalQuickFix.EMPTY_ARRAY, messageKey, args);
+    }
 
-                for (int i = 0; i <= 1; i++) {
-                    PsiType expectedArg = PsiUtil.substituteTypeParameter(expectedType, CommonClassNames.JAVA_UTIL_MAP, i, false);
-                    PsiType assignedArg = PsiUtil.substituteTypeParameter(assignedType, CommonClassNames.JAVA_UTIL_MAP, i, false);
-                    if (isNullityConflict(expectedArg, assignedArg)
-                        || expectedArg != null && assignedArg != null
-                        && isNullableNotNullCollectionConflict(expectedArg, assignedArg, visited)) {
-                        return true;
-                    }
-                }
+    private void reportProblem(ProblemsHolder holder, PsiElement anchor, @Nullable LocalQuickFix fix,
+                               @PropertyKey(resourceBundle = JavaAnalysisBundle.BUNDLE) String messageKey, Object... args) {
+        reportProblem(holder, anchor, fix == null ? LocalQuickFix.EMPTY_ARRAY : new LocalQuickFix[]{fix}, messageKey, args);
+    }
 
-                return false;
-            }
+    protected void reportProblem(ProblemsHolder holder, PsiElement anchor, LocalQuickFix [] fixes,
+                                 @PropertyKey(resourceBundle = JavaAnalysisBundle.BUNDLE) String messageKey, Object... args) {
+        reportProblem(holder, anchor, fixes, messageKey, args, messageKey, args);
+    }
 
-            private boolean isNullityConflict(PsiType expected, PsiType assigned) {
-                return DfaPsiUtil.getTypeNullability(expected) == Nullability.NOT_NULL
-                    && DfaPsiUtil.getTypeNullability(assigned) == Nullability.NULLABLE;
-            }
-        };
+    protected void reportProblem(ProblemsHolder holder, PsiElement anchor, LocalQuickFix [] fixes,
+                                 @PropertyKey(resourceBundle = JavaAnalysisBundle.BUNDLE) String descriptionKey, Object [] descriptionArgs,
+                                 @PropertyKey(resourceBundle = JavaAnalysisBundle.BUNDLE) String tooltipKey, Object [] tooltipArgs) {
+        ProblemsHolder.ProblemBuilder builder = holder.problem(anchor, JavaAnalysisBundle.message(descriptionKey, descriptionArgs))
+            .tooltip(JavaAnalysisBundle.message(tooltipKey, tooltipArgs))
+            .highlight(ProblemHighlightType.GENERIC_ERROR_OR_WARNING);
+        for (LocalQuickFix quickFix : fixes) {
+            builder.fix(quickFix);
+        }
+        builder.register();
     }
 
-    @Nullable
-    @RequiredReadAction
-    private String checkIndirectInheritance(PsiElement psiClass, PsiClass intf, NullableStuffInspectionState state) {
+    private @Nullable String checkIndirectInheritance(PsiClass psiClass, PsiClass intf, NullableStuffInspectionState state) {
+        PsiSubstitutor substitutor = TypeConversionUtil.getSuperClassSubstitutor(intf, psiClass, PsiSubstitutor.EMPTY);
         for (PsiMethod intfMethod : intf.getAllMethods()) {
             PsiClass intfMethodClass = intfMethod.getContainingClass();
             PsiMethod overridingMethod = intfMethodClass == null ? null :
-                JavaOverridingMethodsSearcher.findOverridingMethod((PsiClass)psiClass, intfMethod, intfMethodClass);
+                JavaOverridingMethodsSearcher.findOverridingMethod(psiClass, intfMethod, intfMethodClass);
             PsiClass overridingMethodClass = overridingMethod == null ? null : overridingMethod.getContainingClass();
             if (overridingMethodClass != null && overridingMethodClass != psiClass) {
-                String error = checkIndirectInheritance(intfMethod, intfMethodClass, overridingMethod, overridingMethodClass, state);
+                String error = checkIndirectInheritance(intfMethod, intfMethodClass, overridingMethod, overridingMethodClass, substitutor, state);
                 if (error != null) {
                     return error;
                 }
@@ -362,24 +641,19 @@ private String checkIndirectInheritance(PsiElement psiClass, PsiClass intf, Null
         return null;
     }
 
-    @Nullable
-    @RequiredReadAction
-    private String checkIndirectInheritance(
-        PsiMethod intfMethod,
-        PsiClass intfMethodClass,
-        PsiMethod overridingMethod,
-        PsiClass overridingMethodClass,
-        NullableStuffInspectionState state
-    ) {
+    private @Nullable String checkIndirectInheritance(PsiMethod intfMethod,
+                                                      PsiClass intfMethodClass,
+                                                      PsiMethod overridingMethod,
+                                                      PsiClass overridingMethodClass,
+                                                      PsiSubstitutor substitutor,
+                                                      NullableStuffInspectionState state) {
         if (isNullableOverridingNotNull(Annotated.from(overridingMethod), intfMethod, state)) {
-            return "Nullable method '" + overridingMethod.getName() +
-                "' from '" + overridingMethodClass.getName() +
-                "' implements non-null method from '" + intfMethodClass.getName() + "'";
+            return JavaAnalysisBundle.message("inspection.message.nullable.method.implements.non.null.method",
+                overridingMethod.getName(), overridingMethodClass.getName(), intfMethodClass.getName());
         }
         if (isNonAnnotatedOverridingNotNull(overridingMethod, intfMethod, state)) {
-            return "Non-annotated method '" + overridingMethod.getName() +
-                "' from '" + overridingMethodClass.getName() +
-                "' implements non-null method from '" + intfMethodClass.getName() + "'";
+            return JavaAnalysisBundle.message("inspection.message.non.annotated.method.implements.non.null.method",
+                overridingMethod.getName(), overridingMethodClass.getName(), intfMethodClass.getName());
         }
 
         PsiParameter[] overridingParameters = overridingMethod.getParameterList().getParameters();
@@ -389,23 +663,17 @@ private String checkIndirectInheritance(
             for (int i = 0; i < overridingParameters.length; i++) {
                 PsiParameter parameter = overridingParameters[i];
                 List<PsiParameter> supers = Collections.singletonList(superParameters[i]);
-                if (findNullableSuperForNotNullParameter(parameter, supers, state) != null) {
-                    return "Non-null parameter '" + parameter.getName() +
-                        "' in method '" + overridingMethod.getName() +
-                        "' from '" + overridingMethodClass.getName() +
-                        "' should not override nullable parameter from '" + intfMethodClass.getName() + "'";
+                if (findNullableSuperForNotNullParameter(parameter, supers, substitutor, state) != null) {
+                    return JavaAnalysisBundle.message("inspection.message.non.null.parameter.should.not.override.nullable.parameter",
+                        parameter.getName(), overridingMethod.getName(), overridingMethodClass.getName(), intfMethodClass.getName());
                 }
-                if (findNotNullSuperForNonAnnotatedParameter(manager, parameter, supers, state) != null) {
-                    return "Non-annotated parameter '" + parameter.getName() +
-                        "' in method '" + overridingMethod.getName() +
-                        "' from '" + overridingMethodClass.getName() +
-                        "' should not override non-null parameter from '" + intfMethodClass.getName() + "'";
+                if (findNotNullSuperForNonAnnotatedParameter(manager, parameter, super, states) != null) {
+                    return JavaAnalysisBundle.message("inspection.message.non.annotated.parameter.should.not.override.non.null.parameter",
+                        parameter.getName(), overridingMethod.getName(), overridingMethodClass.getName(), intfMethodClass.getName());
                 }
-                if (isNotNullParameterOverridingNonAnnotated(manager, parameter, supers, state)) {
-                    return "Non-null parameter '" + parameter.getName() +
-                        "' in method '" + overridingMethod.getName() +
-                        "' from '" + overridingMethodClass.getName() +
-                        "' should not override non-annotated parameter from '" + intfMethodClass.getName() + "'";
+                if (isNotNullParameterOverridingNonAnnotated(manager, parameter, supers, substitutor, state)) {
+                    return JavaAnalysisBundle.message("inspection.message.non.null.parameter.should.not.override.non.annotated.parameter",
+                        parameter.getName(), overridingMethod.getName(), overridingMethodClass.getName(), intfMethodClass.getName());
                 }
             }
         }
@@ -413,14 +681,9 @@ private String checkIndirectInheritance(
         return null;
     }
 
-    @RequiredReadAction
-    private void checkMethodReference(
-        PsiMethodReferenceExpression expression,
-        ProblemsHolder holder,
-        NullableStuffInspectionState state
-    ) {
+    private void checkMethodReference(PsiMethodReferenceExpression expression, ProblemsHolder holder, NullableStuffInspectionState state) {
         PsiMethod superMethod = LambdaUtil.getFunctionalInterfaceMethod(expression);
-        PsiMethod targetMethod = ObjectUtil.tryCast(expression.resolve(), PsiMethod.class);
+        PsiMethod targetMethod = tryCast(expression.resolve(), PsiMethod.class);
         if (superMethod == null || targetMethod == null) {
             return;
         }
@@ -428,23 +691,8 @@ private void checkMethodReference(
         PsiElement refName = expression.getReferenceNameElement();
         assert refName != null;
         if (isNullableOverridingNotNull(check(targetMethod, holder, expression.getType()), superMethod, state)) {
-            holder.newProblem(LocalizeValue.of(InspectionsBundle.message(
-                    "inspection.nullable.problems.Nullable.method.overrides.NotNull",
-                    getPresentableAnnoName(targetMethod),
-                    getPresentableAnnoName(superMethod)
-                )))
-                .range(refName)
-                .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-                .create();
-        }
-        else if (isNonAnnotatedOverridingNotNull(targetMethod, superMethod, state)) {
-            holder.newProblem(LocalizeValue.localizeTODO(
-                    "Not annotated method is used as an override for a method annotated with " + getPresentableAnnoName(superMethod)
-                ))
-                .range(refName)
-                .withFixes(createFixForNonAnnotatedOverridesNotNull(targetMethod, superMethod))
-                .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-                .create();
+            reportProblem(holder, refName, "inspection.nullable.problems.Nullable.method.overrides.NotNull",
+                getPresentableAnnoName(targetMethod), getPresentableAnnoName(superMethod));
         }
     }
 
@@ -456,77 +704,35 @@ private static boolean nullabilityAnnotationsNotAvailable(PsiFile file) {
         Project project = file.getProject();
         GlobalSearchScope scope = GlobalSearchScope.allScope(project);
         JavaPsiFacade facade = JavaPsiFacade.getInstance(project);
-        return ContainerUtil.find(
-            NullableNotNullManager.getInstance(project).getNullables(),
-            s -> facade.findClass(s, scope) != null
-        ) == null;
-    }
-
-    private static boolean checkNonStandardAnnotations(
-        PsiField field,
-        Annotated annotated,
-        NullableNotNullManager manager,
-        String anno,
-        ProblemsHolder holder
-    ) {
-        if (!AnnotationUtil.isAnnotatingApplicable(field, anno)) {
-            PsiAnnotation annotation = Objects.requireNonNull(annotated.isDeclaredNullable ? annotated.nullable : annotated.notNull);
-            PsiJavaCodeReferenceElement annotationNameReferenceElement = annotation.getNameReferenceElement();
-            holder.newProblem(LocalizeValue.localizeTODO(
-                    "Not \'" + annotation.getQualifiedName() + "\' but \'" + anno + "\' would be used for code generation."
-                ))
-                .range(
-                    annotationNameReferenceElement != null && annotationNameReferenceElement.isPhysical()
-                        ? annotationNameReferenceElement
-                        : field.getNameIdentifier()
-                )
-                .withFixes(new ChangeNullableDefaultsFix(annotated.notNull, annotated.nullable, manager))
-                .highlightType(ProblemHighlightType.WEAK_WARNING)
-                .create();
-            return false;
-        }
-        return true;
+        return ContainerUtil.find(NullableNotNullManager.getInstance(project).getNullables(), s -> facade.findClass(s, scope) != null) == null;
     }
 
-    @RequiredReadAction
-    private void checkAccessors(
-        PsiField field,
-        Annotated annotated,
-        Project project,
-        NullableNotNullManager manager,
-        String anno,
-        List<String> annoToRemove,
-        ProblemsHolder holder,
-        NullableStuffInspectionState state
-    ) {
+    private void checkAccessors(PsiField field,
+                                Annotated annotated,
+                                Project project,
+                                NullableNotNullManager manager,
+                                String anno,
+                                List<String> annoToRemove,
+                                ProblemsHolder holder,
+                                NullableStuffInspectionState state) {
         String propName = JavaCodeStyleManager.getInstance(project).variableNameToPropertyName(field.getName(), VariableKind.FIELD);
-        boolean isStatic = field.isStatic();
+        boolean isStatic = field.hasModifierProperty(PsiModifier.STATIC);
         PsiMethod getter = PropertyUtilBase.findPropertyGetter(field.getContainingClass(), propName, isStatic, false);
         PsiIdentifier nameIdentifier = getter == null ? null : getter.getNameIdentifier();
         if (nameIdentifier != null && nameIdentifier.isPhysical()) {
             if (PropertyUtil.getFieldOfGetter(getter) == field) {
-                AnnotateMethodFix getterAnnoFix = new AnnotateMethodFix(anno, ArrayUtil.toStringArray(annoToRemove));
-                if (state.REPORT_NOT_ANNOTATED_GETTER) {
-                    if (!manager.hasNullability(getter) && !TypeConversionUtil.isPrimitiveAndNotNull(getter.getReturnType())) {
-                        holder.newProblem(InspectionLocalize.inspectionNullableProblemsAnnotatedFieldGetterNotAnnotated(
-                                getPresentableAnnoName(field)
-                            ))
-                            .range(nameIdentifier)
-                            .withFixes(getterAnnoFix)
-                            .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-                            .create();
+                AddAnnotationModCommandAction getterAnnoFix = new AddAnnotationModCommandAction(anno, getter, ArrayUtil.toStringArray(annoToRemove));
+                if (satte.REPORT_NOT_ANNOTATED_GETTER) {
+                    if (!hasNullability(manager, getter) && !TypeConversionUtil.isPrimitiveAndNotNull(getter.getReturnType())) {
+                        reportProblem(holder, nameIdentifier, getterAnnoFix, "inspection.nullable.problems.annotated.field.getter.not.annotated",
+                            StringUtil.getShortName(anno));
                     }
                 }
-                if (annotated.isDeclaredNotNull && isNullableNotInferred(getter, false)
-                    || annotated.isDeclaredNullable && isNotNullNotInferred(getter, false, false)) {
-                    holder.newProblem(InspectionLocalize.inspectionNullableProblemsAnnotatedFieldGetterConflict(
-                            getPresentableAnnoName(field),
-                            getPresentableAnnoName(getter)
-                        ))
-                        .range(nameIdentifier)
-                        .withFixes(getterAnnoFix)
-                        .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-                        .create();
+                if (annotated.isDeclaredNotNull && isNullableNotInferred(getter, false) ||
+                    annotated.isDeclaredNullable && isNotNullNotInferred(getter, false, false)) {
+                    reportProblem(holder, nameIdentifier, getterAnnoFix,
+                        "inspection.nullable.problems.annotated.field.getter.conflict", getPresentableAnnoName(field),
+                        getPresentableAnnoName(getter));
                 }
             }
         }
@@ -538,88 +744,64 @@ private void checkAccessors(
             assert parameters.length == 1 : setter.getText();
             PsiParameter parameter = parameters[0];
             LOG.assertTrue(parameter != null, setter.getText());
-            AddAnnotationPsiFix addAnnoFix = createAddAnnotationFix(anno, annoToRemove, parameter);
-            if (state.REPORT_NOT_ANNOTATED_GETTER && !manager.hasNullability(parameter)
-                && !TypeConversionUtil.isPrimitiveAndNotNull(parameter.getType())) {
+            AddAnnotationFix addAnnoFix = createAddAnnotationFix(anno, annoToRemove, parameter);
+            if (state.REPORT_NOT_ANNOTATED_GETTER && !hasNullability(manager, parameter) && !TypeConversionUtil.isPrimitiveAndNotNull(parameter.getType())) {
                 PsiIdentifier parameterName = parameter.getNameIdentifier();
                 assertValidElement(setter, parameter, parameterName);
-                holder.newProblem(InspectionLocalize.inspectionNullableProblemsAnnotatedFieldSetterParameterNotAnnotated(
-                        getPresentableAnnoName(field)
-                    ))
-                    .range(parameterName)
-                    .withFixes(addAnnoFix)
-                    .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-                    .create();
+                reportProblem(holder, parameterName, addAnnoFix,
+                    "inspection.nullable.problems.annotated.field.setter.parameter.not.annotated", getPresentableAnnoName(field));
             }
             if (PropertyUtil.isSimpleSetter(setter)) {
                 if (annotated.isDeclaredNotNull && isNullableNotInferred(parameter, false)) {
                     PsiIdentifier parameterName = parameter.getNameIdentifier();
                     assertValidElement(setter, parameter, parameterName);
-                    holder.newProblem(InspectionLocalize.inspectionNullableProblemsAnnotatedFieldSetterParameterConflict(
-                            getPresentableAnnoName(field),
-                            getPresentableAnnoName(parameter)
-                        ))
-                        .range(parameterName)
-                        .withFixes(addAnnoFix)
-                        .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-                        .create();
+                    reportProblem(holder, parameterName, addAnnoFix,
+                        "inspection.nullable.problems.annotated.field.setter.parameter.conflict",
+                        getPresentableAnnoName(field), getPresentableAnnoName(parameter));
                 }
             }
         }
     }
 
-    @RequiredReadAction
-    private static AddAnnotationPsiFix createAddAnnotationFix(String anno, List<String> annoToRemove, PsiParameter parameter) {
-        return new AddAnnotationPsiFix(anno, parameter, PsiNameValuePair.EMPTY_ARRAY, ArrayUtil.toStringArray(annoToRemove));
+    private static AddAnnotationFix createAddAnnotationFix(String anno, List<String> annoToRemove, PsiParameter parameter) {
+        return new AddAnnotationFix(anno, parameter, annoToRemove.toArray(ArrayUtil.EMPTY_STRING_ARRAY));
     }
 
     @Contract("_,_,null -> fail")
-    @RequiredReadAction
     private static void assertValidElement(PsiMethod setter, PsiParameter parameter, PsiIdentifier nameIdentifier1) {
         LOG.assertTrue(nameIdentifier1 != null && nameIdentifier1.isPhysical(), setter.getText());
         LOG.assertTrue(parameter.isPhysical(), setter.getText());
     }
 
-    @RequiredReadAction
-    private void checkConstructorParameters(
-        PsiField field,
-        Annotated annotated,
-        NullableNotNullManager manager,
-        String anno,
-        List<String> annoToRemove,
-        ProblemsHolder holder,
-        NullableStuffInspectionState state
-    ) {
+    private void checkConstructorParameters(PsiField field,
+                                            Annotated annotated,
+                                            String anno,
+                                            List<String> annoToRemove,
+                                            ProblemsHolder holder,
+                                            NullableStuffInspectionState state) {
         List<PsiExpression> initializers = DfaPsiUtil.findAllConstructorInitializers(field);
         if (initializers.isEmpty()) {
             return;
         }
 
-        List<PsiParameter> notNullParams = new ArrayList<>();
+        if (state.REPORT_NOT_ANNOTATED_GETTER) {
+            reportConstructorParameterFromField(field, anno, annoToRemove, holder, initializers);
+        }
 
-        boolean isFinal = field.isFinal();
+        if (field.hasModifierProperty(PsiModifier.FINAL)) {
+            checkFinalFieldInitializedNotNull(field, annotated, holder, initializers);
+        }
+    }
 
+    private void checkFinalFieldInitializedNotNull(PsiField field, Annotated annotated,
+                                                   ProblemsHolder holder, List<PsiExpression> initializers) {
+        List<PsiParameter> notNullParams = new ArrayList<>();
         for (PsiExpression rhs : initializers) {
-            if (rhs instanceof PsiReferenceExpression referenceExpression) {
-                PsiElement target = referenceExpression.resolve();
+            if (rhs instanceof PsiReferenceExpression ref) {
+                PsiElement target = ref.resolve();
                 if (isConstructorParameter(target) && target.isPhysical()) {
-                    PsiParameter parameter = (PsiParameter)target;
-                    if (state.REPORT_NOT_ANNOTATED_GETTER
-                        && !manager.hasNullability(parameter) && !TypeConversionUtil.isPrimitiveAndNotNull(parameter.getType())) {
-                        PsiIdentifier nameIdentifier = parameter.getNameIdentifier();
-                        if (nameIdentifier != null && nameIdentifier.isPhysical()) {
-                            holder.newProblem(InspectionLocalize.inspectionNullableProblemsAnnotatedFieldConstructorParameterNotAnnotated(
-                                    getPresentableAnnoName(field)
-                                ))
-                                .range(nameIdentifier)
-                                .withFixes(createAddAnnotationFix(anno, annoToRemove, parameter))
-                                .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-                                .create();
-                            continue;
-                        }
-                    }
-
-                    if (isFinal && annotated.isDeclaredNullable && isNotNullNotInferred(parameter, false, false)) {
+                    PsiParameter parameter = (PsiParameter) target;
+                    if (annotated.isDeclaredNullable && isNotNullNotInferred(parameter, false, false)) {
                         notNullParams.add(parameter);
                     }
                 }
@@ -627,25 +809,57 @@ private void checkConstructorParameters(
         }
 
         if (notNullParams.size() != initializers.size()) {
-            // it's not the case that the field is final and @Nullable and always initialized via @NotNull parameters
-            // so there might be other initializers that could justify it being nullable
+            // it's not the case that the field is and @Nullable and always initialized via parameters, 
+            // so there might be other initializers that could justify it being nullable, 
             // so don't highlight field and constructor parameter annotation inconsistency
             return;
         }
 
         PsiIdentifier nameIdentifier = field.getNameIdentifier();
         if (nameIdentifier.isPhysical()) {
-            holder.newProblem(LocalizeValue.localizeTODO("@" + getPresentableAnnoName(field) + " field is always initialized not-null"))
-                .range(nameIdentifier)
-                .withFixes(AddAnnotationPsiFix.createAddNotNullFix(field))
-                .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-                .create();
+            reportProblem(holder, nameIdentifier, AddAnnotationModCommandAction.createAddNotNullFix(field),
+                "0.field.is.always.initialized.not.null", getPresentableAnnoName(field));
         }
     }
 
+    private void reportConstructorParameterFromField(PsiField field,
+                                                     String anno,
+                                                     List<String> annoToRemove,
+                                                     ProblemsHolder holder,
+                                                     List<PsiExpression> initializers) {
+        Map<PsiMethod, List<PsiExpression>> ctorToInitializers = StreamEx.of(initializers)
+            .mapToEntry(e -> PsiTreeUtil.getParentOfType(e, PsiMethod.class), e -> e)
+            .nonNullKeys()
+            .filterKeys(PsiMethod::isConstructor)
+            .grouping();
+
+        ctorToInitializers.forEach((ctor, exprs) -> {
+            List<PsiParameter> parameters = StreamEx.of(exprs)
+                .map(e -> PsiUtil.skipParenthesizedExprDown(e) instanceof PsiReferenceExpression ref
+                    ? tryCast(ref.resolve(), PsiParameter.class)
+                    : null)
+                .distinct()
+                .limit(2)
+                .toList();
+            if (parameters.size() != 1) {
+                return;
+            }
+            PsiParameter parameter = parameters.getFirst();
+            if (parameter != null && parameter.getDeclarationScope() == ctor
+                && !hasNullability(NullableNotNullManager.getInstance(field.getProject()), parameter)
+                && !TypeConversionUtil.isPrimitiveAndNotNull(parameter.getType())) {
+                PsiIdentifier nameIdentifier = parameter.getNameIdentifier();
+                if (nameIdentifier != null && nameIdentifier.isPhysical()) {
+                    reportProblem(holder, nameIdentifier, createAddAnnotationFix(anno, annoToRemove, parameter),
+                        "inspection.nullable.problems.annotated.field.constructor.parameter.not.annotated",
+                        StringUtil.getShortName(anno));
+                }
+            }
+        });
+    }
+
     private static boolean isConstructorParameter(@Nullable PsiElement parameter) {
-        return parameter instanceof PsiParameter &&
-            psiElement(PsiParameterList.class).withParent(psiMethod().constructor(true)).accepts(parameter.getParent());
+        return parameter instanceof PsiParameter && psiElement(PsiParameterList.class).withParent(psiMethod().constructor(true)).accepts(parameter.getParent());
     }
 
     private static String getPresentableAnnoName(PsiModifierListOwner owner) {
@@ -662,13 +876,20 @@ public static String getPresentableAnnoName(PsiAnnotation annotation) {
         return StringUtil.getShortName(StringUtil.notNullize(annotation.getQualifiedName(), "???"));
     }
 
+    /**
+     * @return true if the owner has a or @Nullable annotation,
+     * or is in scope of @ParametersAreNullableByDefault or ParametersAreNonnullByDefault
+     */
+    private static boolean hasNullability(NullableNotNullManager manager, PsiModifierListOwner owner) {
+        NullabilityAnnotationInfo info = manager.findEffectiveNullabilityInfo(owner);
+        return info != null && info.getNullability() != Nullability.UNKNOWN && info.getInheritedFrom() == null;
+    }
+
     private static class Annotated {
-        private final boolean isDeclaredNotNull;
-        private final boolean isDeclaredNullable;
-        @Nullable
-        private final PsiAnnotation notNull;
-        @Nullable
-        private final PsiAnnotation nullable;
+        private boolean isDeclaredNotNull;
+        private boolean isDeclaredNullable;
+        private @Nullable PsiAnnotation notNull;
+        private @Nullable PsiAnnotation nullable;
 
         private Annotated(@Nullable PsiAnnotation notNull, @Nullable PsiAnnotation nullable) {
             this.isDeclaredNotNull = notNull != null;
@@ -679,80 +900,56 @@ private Annotated(@Nullable PsiAnnotation notNull, @Nullable PsiAnnotation nulla
 
         static Annotated from(PsiModifierListOwner owner) {
             NullableNotNullManager manager = NullableNotNullManager.getInstance(owner.getProject());
-            return new Annotated(
-                manager.findExplicitNullabilityAnnotation(owner, Collections.singleton(Nullability.NOT_NULL)),
-                manager.findExplicitNullabilityAnnotation(owner, Collections.singleton(Nullability.NULLABLE))
-            );
+            NullabilityAnnotationInfo notNullInfo = manager.findNullabilityAnnotationInfo(owner, Collections.singleton(Nullability.NOT_NULL));
+            NullabilityAnnotationInfo nullableInfo = manager.findNullabilityAnnotationInfo(owner, Collections.singleton(Nullability.NULLABLE));
+            PsiAnnotation notNullAnno = notNullInfo == null || (notNullInfo.isContainer() && nullableInfo != null && !nullableInfo.isContainer())
+                ? null : notNullInfo.getAnnotation();
+            PsiAnnotation nullableAnno = nullableInfo == null || (nullableInfo.isContainer() && notNullInfo != null && !notNullInfo.isContainer())
+                ? null : nullableInfo.getAnnotation();
+            return new Annotated(notNullAnno, nullableAnno);
         }
     }
 
-    private static Annotated check(PsiModifierListOwner owner, ProblemsHolder holder, PsiType type) {
+    private Annotated check(PsiModifierListOwner owner, ProblemsHolder holder, PsiType type) {
         Annotated annotated = Annotated.from(owner);
-        checkType(owner, holder, type, annotated.notNull, annotated.nullable);
-        return annotated;
-    }
-
-    private static void checkType(
-        @Nullable PsiModifierListOwner listOwner,
-        ProblemsHolder holder,
-        PsiType type,
-        @Nullable PsiAnnotation notNull,
-        @Nullable PsiAnnotation nullable
-    ) {
-        if (nullable != null && notNull != null) {
-            reportNullableNotNullConflict(holder, listOwner, nullable, notNull);
+        PsiAnnotation annotation = annotated.notNull == null ? annotated.nullable : annotated.notNull;
+        if (annotation != null && !annotation.isPhysical() && type instanceof PsiPrimitiveType) {
+            reportIncorrectLocation(holder, annotation, owner, "inspection.nullable.problems.primitive.type.annotation");
         }
-        if ((notNull != null || nullable != null) && type != null && TypeConversionUtil.isPrimitive(type.getCanonicalText())) {
-            PsiAnnotation annotation = notNull == null ? nullable : notNull;
-            reportPrimitiveType(holder, annotation, listOwner);
-        }
-        if (listOwner instanceof PsiParameter psiParameter) {
-            checkLoopParameterNullability(
-                holder,
-                notNull,
-                nullable,
-                DfaPsiUtil.inferParameterNullability((PsiParameter)listOwner),
-                psiParameter
-            );
+        if (owner instanceof PsiParameter parameter) {
+            Nullability expectedNullability = DfaPsiUtil.inferParameterNullability(parameter);
+            if (annotated.notNull != null && expectedNullability == Nullability.NULLABLE) {
+                reportParameterNullabilityMismatch(parameter, annotated.notNull, holder, "parameter.can.be.null");
+            }
+            else if (annotated.nullable != null && expectedNullability == Nullability.NOT_NULL) {
+                reportParameterNullabilityMismatch(parameter, annotated.nullable, holder, "parameter.is.always.not.null");
+            }
         }
+        return annotated;
     }
 
-    private static void checkLoopParameterNullability(
-        ProblemsHolder holder,
-        @Nullable PsiAnnotation notNull,
-        @Nullable PsiAnnotation nullable,
-        Nullability expectedNullability,
-        PsiParameter owner
-    ) {
-        if (notNull != null && expectedNullability == Nullability.NULLABLE) {
-            holder.newProblem(LocalizeValue.localizeTODO("Parameter can be null"))
-                .range(notNull)
-                .withFixes(new RemoveAnnotationQuickFix(notNull, null))
-                .create();
+    private void reportParameterNullabilityMismatch(PsiParameter owner,
+                                                    PsiAnnotation annotation,
+                                                    ProblemsHolder holder,
+                                                    @PropertyKey(resourceBundle = JavaAnalysisBundle.BUNDLE) String messageKey) {
+        if (annotation.isPhysical() && !PsiTreeUtil.isAncestor(owner, annotation, true)) {
+            return;
         }
-        else if (nullable != null && expectedNullability == Nullability.NOT_NULL) {
-            if (nullable.getContainingFile() != owner.getContainingFile()) {
-                return;
-            }
-
-            holder.newProblem(LocalizeValue.localizeTODO("Parameter is always not-null"))
-                .range(nullable)
-                .withFixes(new RemoveAnnotationQuickFix(nullable, null))
-                .create();
+        PsiElement anchor = annotation.isPhysical() ? annotation : owner.getNameIdentifier();
+        if (anchor != null && !anchor.getTextRange().isEmpty()) {
+            reportProblem(holder, anchor, new RemoveAnnotationQuickFix(annotation, owner), messageKey);
         }
     }
 
-    private static void reportPrimitiveType(
-        ProblemsHolder holder,
-        PsiAnnotation annotation,
-        @Nullable PsiModifierListOwner listOwner
-    ) {
-        PsiElement psiElement = !annotation.isPhysical() && listOwner != null ? listOwner.getNavigationElement() : annotation;
-        holder.newProblem(InspectionLocalize.inspectionNullableProblemsPrimitiveTypeAnnotation())
-            .range(psiElement)
-            .withFixes(new RemoveAnnotationQuickFix(annotation, listOwner))
-            .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-            .create();
+    private void reportIncorrectLocation(ProblemsHolder holder, PsiAnnotation annotation,
+                                         @Nullable PsiModifierListOwner listOwner,
+                                         @PropertyKey(resourceBundle = JavaAnalysisBundle.BUNDLE) String messageKey,
+                                         LocalQuickFix ... additionalFixes) {
+        RemoveAnnotationQuickFix removeFix = new RemoveAnnotationQuickFix(annotation, listOwner, true);
+        MoveAnnotationToBoundFix moveToBoundFix = MoveAnnotationToBoundFix.create(annotation);
+        LocalQuickFix[] fixes = moveToBoundFix == null ? new LocalQuickFix[]{removeFix} : new LocalQuickFix[]{moveToBoundFix, removeFix};
+        reportProblem(holder, !annotation.isPhysical() && listOwner != null ? listOwner.getNavigationElement() : annotation,
+            ArrayUtil.mergeArrays(additionalFixes, fixes), messageKey);
     }
 
     @Override
@@ -760,68 +957,55 @@ public LocalizeValue getDisplayName() {
         return InspectionLocalize.inspectionNullableProblemsDisplayName();
     }
 
-    @Override
-    public LocalizeValue getGroupDisplayName() {
-        return InspectionLocalize.groupNamesProbableBugs();
-    }
-
     @Override
     public String getShortName() {
         return "NullableProblems";
     }
 
-    @RequiredReadAction
-    private void checkNullableStuffForMethod(
-        PsiMethod method,
-        ProblemsHolder holder,
-        boolean isOnFly,
-        NullableStuffInspectionState state
-    ) {
+    private void checkNullableStuffForMethod(PsiMethod method,
+                                             ProblemsHolder holder,
+                                             NullableStuffInspectionState state) {
         Annotated annotated = check(method, holder, method.getReturnType());
 
         List<PsiMethod> superMethods = ContainerUtil.map(
-            method.findSuperMethodSignaturesIncludingStatic(true),
-            MethodSignatureBackedByPsiMethod::getMethod
-        );
+            method.findSuperMethodSignaturesIncludingStatic(true), MethodSignatureBackedByPsiMethod::getMethod);
 
         NullableNotNullManager nullableManager = NullableNotNullManager.getInstance(holder.getProject());
 
         checkSupers(method, holder, annotated, superMethods, state);
-        checkParameters(method, holder, superMethods, nullableManager, isOnFly, state);
+        checkParameters(method, holder, superMethods, nullableManager, state);
         checkOverriders(method, holder, annotated, nullableManager, state);
+        checkConflictingContainerAnnotations(holder, method.getModifierList());
     }
 
-    private void checkSupers(
-        PsiMethod method,
-        ProblemsHolder holder,
-        Annotated annotated,
-        List<? extends PsiMethod> superMethods,
-        NullableStuffInspectionState state
-    ) {
+    private void checkSupers(PsiMethod method,
+                             ProblemsHolder holder,
+                             Annotated annotated,
+                             List<? extends PsiMethod> superMethods,
+                             NullableStuffInspectionState state) {
+        PsiIdentifier identifier = method.getNameIdentifier();
+        if (identifier == null) {
+            return;
+        }
         for (PsiMethod superMethod : superMethods) {
             if (isNullableOverridingNotNull(annotated, superMethod, state)) {
-                PsiAnnotation annotation = AnnotationUtil.findAnnotation(method, getNullityManager(method).getNullables(), true);
-                holder.newProblem(LocalizeValue.localizeTODO(InspectionsBundle.message(
-                        "inspection.nullable.problems.Nullable.method.overrides.NotNull",
-                        getPresentableAnnoName(method),
-                        getPresentableAnnoName(superMethod)
-                    )))
-                    .range(annotation != null ? annotation : method.getNameIdentifier())
-                    .withFixes()
-                    .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-                    .create();
+                PsiAnnotation annotation = findAnnotation(method, getNullityManager(method).getNullables(), true);
+                reportProblem(holder, annotation != null ? annotation : identifier,
+                    "inspection.nullable.problems.Nullable.method.overrides.NotNull",
+                    getPresentableAnnoName(method), getPresentableAnnoName(superMethod));
                 break;
             }
 
             if (isNonAnnotatedOverridingNotNull(method, superMethod, state)) {
-                holder.newProblem(LocalizeValue.of(InspectionsBundle.message(
-                        "inspection.nullable.problems.method.overrides.NotNull",
-                        getPresentableAnnoName(superMethod)
-                    )))
-                    .range(method.getNameIdentifier())
-                    .withFixes(createFixForNonAnnotatedOverridesNotNull(method, superMethod))
-                    .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-                    .create();
+                reportProblem(holder, identifier, createFixForNonAnnotatedOverridesNotNull(method),
+                    "inspection.nullable.problems.method.overrides.NotNull", getPresentableAnnoName(superMethod));
+                break;
+            }
+
+            PsiTypeElement returnTypeElement = method.getReturnTypeElement();
+            if (returnTypeElement != null &&
+                checkNestedGenericClasses(holder, returnTypeElement, superMethod.getReturnType(), method.getReturnType(),
+                    ConflictNestedTypeProblem.OVERRIDING_NESTED_TYPE_PROBLEM, state)) {
                 break;
             }
         }
@@ -831,45 +1015,42 @@ private static NullableNotNullManager getNullityManager(PsiMethod method) {
         return NullableNotNullManager.getInstance(method.getProject());
     }
 
-    @Nullable
-    @RequiredReadAction
-    private static LocalQuickFix createFixForNonAnnotatedOverridesNotNull(
-        PsiMethod method,
-        PsiMethod superMethod
-    ) {
+    private static @Nullable LocalQuickFix createFixForNonAnnotatedOverridesNotNull(PsiMethod method) {
         NullableNotNullManager nullableManager = getNullityManager(method);
-        return AnnotationUtil.isAnnotatingApplicable(method, nullableManager.getDefaultNotNull())
-            ? AddAnnotationPsiFix.createAddNotNullFix(method)
-            : createChangeDefaultNotNullFix(nullableManager, superMethod);
+        return isAnnotatingApplicable(method, nullableManager.getDefaultNotNull())
+            ? LocalQuickFix.from(AddAnnotationModCommandAction.createAddNotNullFix(method))
+            : null;
     }
 
     private boolean isNullableOverridingNotNull(Annotated methodInfo, PsiMethod superMethod, NullableStuffInspectionState state) {
-        return state.REPORT_NOTNULL_PARAMETER_OVERRIDES_NULLABLE && methodInfo.isDeclaredNullable
-            && isNotNullNotInferred(superMethod, true, false);
+        return state.REPORT_NOTNULL_PARAMETER_OVERRIDES_NULLABLE && methodInfo.isDeclaredNullable && isNotNullNotInferred(superMethod, true, false);
     }
 
     private boolean isNonAnnotatedOverridingNotNull(PsiMethod method, PsiMethod superMethod, NullableStuffInspectionState state) {
-        return state.REPORT_NOT_ANNOTATED_METHOD_OVERRIDES_NOTNULL
-            && !(method.getReturnType() instanceof PsiPrimitiveType)
-            && !method.isConstructor()
-            && !getNullityManager(method).hasNullability(method)
-            && isNotNullNotInferred(superMethod, true, state.IGNORE_EXTERNAL_SUPER_NOTNULL)
-            && !hasInheritableNotNull(superMethod);
+        if (state.REPORT_NOT_ANNOTATED_METHOD_OVERRIDES_NOTNULL &&
+            !(method.getReturnType() instanceof PsiPrimitiveType) &&
+            !method.isConstructor()) {
+            NullableNotNullManager manager = getNullityManager(method);
+            NullabilityAnnotationInfo info = manager.findEffectiveNullabilityInfo(method);
+            if ((info == null || info.isInferred() ||
+                (info.getInheritedFrom() != null && manager.findContainerAnnotation(method) == null)) &&
+                isNotNullNotInferred(superMethod, true, state.IGNORE_EXTERNAL_SUPER_NOTNULL) &&
+                !hasInheritableNotNull(superMethod)) {
+                return true;
+            }
+        }
+        return false;
     }
 
     private static boolean hasInheritableNotNull(PsiModifierListOwner owner) {
-        return AnnotationUtil.isAnnotated(owner, "javax.annotation.constraints.NotNull", CHECK_HIERARCHY | CHECK_TYPE);
+        return isAnnotated(owner, "javax.annotation.constraints.NotNull", CHECK_HIERARCHY | CHECK_TYPE);
     }
 
-    @RequiredReadAction
-    private void checkParameters(
-        PsiMethod method,
-        ProblemsHolder holder,
-        List<? extends PsiMethod> superMethods,
-        NullableNotNullManager nullableManager,
-        boolean isOnFly,
-        NullableStuffInspectionState state
-    ) {
+    private void checkParameters(PsiMethod method,
+                                 ProblemsHolder holder,
+                                 List<? extends PsiMethod> superMethods,
+                                 NullableNotNullManager nullableManager,
+                                 NullableStuffInspectionState state) {
         PsiParameter[] parameters = method.getParameterList().getParameters();
         for (int i = 0; i < parameters.length; i++) {
             PsiParameter parameter = parameters[i];
@@ -877,148 +1058,187 @@ private void checkParameters(
                 continue;
             }
 
-            List<PsiParameter> superParameters = new ArrayList<>();
-            for (PsiMethod superMethod : superMethods) {
-                PsiParameter[] _superParameters = superMethod.getParameterList().getParameters();
-                if (_superParameters.length == parameters.length) {
-                    superParameters.add(_superParameters[i]);
-                }
-            }
+            List<PsiParameter> superParameters = getSuperParameters(superMethods, parameters, i);
 
-            PsiParameter nullableSuper = findNullableSuperForNotNullParameter(parameter, superParameters, state);
-            if (nullableSuper != null) {
-                PsiAnnotation annotation = AnnotationUtil.findAnnotation(parameter, nullableManager.getNotNulls(), true);
-                holder.newProblem(LocalizeValue.of(InspectionsBundle.message(
-                        "inspection.nullable.problems.NotNull.parameter.overrides.Nullable",
-                        getPresentableAnnoName(parameter),
-                        getPresentableAnnoName(nullableSuper)
-                    )))
-                    .range(annotation != null ? annotation : parameter.getNameIdentifier())
-                    .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-                    .create();
-            }
-            PsiParameter notNullSuper = findNotNullSuperForNonAnnotatedParameter(nullableManager, parameter, superParameters, state);
-            if (notNullSuper != null) {
-                LocalQuickFix fix = AnnotationUtil.isAnnotatingApplicable(parameter, nullableManager.getDefaultNotNull())
-                    ? AddAnnotationPsiFix.createAddNotNullFix(parameter)
-                    : createChangeDefaultNotNullFix(nullableManager, notNullSuper);
-                holder.newProblem(LocalizeValue.of(InspectionsBundle.message(
-                        "inspection.nullable.problems.parameter.overrides.NotNull",
-                        getPresentableAnnoName(notNullSuper)
-                    )))
-                    .range(parameter.getNameIdentifier())
-                    .withFixes(fix)
-                    .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-                    .create();
-            }
-            if (isNotNullParameterOverridingNonAnnotated(nullableManager, parameter, superParameters, state)) {
-                NullabilityAnnotationInfo info = nullableManager.findOwnNullabilityInfo(parameter);
-                assert info != null;
-                PsiAnnotation notNullAnnotation = info.getAnnotation();
-                boolean physical = PsiTreeUtil.isAncestor(parameter, notNullAnnotation, true);
-                LocalQuickFix fix = physical ? new RemoveAnnotationQuickFix(notNullAnnotation, parameter) : null;
-                PsiElement psiElement = physical ? notNullAnnotation : parameter.getNameIdentifier();
-                holder.newProblem(JavaInspectionsLocalize.inspectionNullableProblemsNotnullParameterOverridesNotAnnotated(
-                        getPresentableAnnoName(parameter)
-                    ))
-                    .range(psiElement)
-                    .withFixes(fix)
-                    .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-                    .create();
+            checkSuperParameterAnnotations(holder, nullableManager, parameter, superParameters);
+
+            checkNullLiteralArgumentOfNotNullParameterUsages(method, holder, nullableManager, i, parameter, state);
+        }
+    }
+
+    private static List<PsiParameter> getSuperParameters(List<? extends PsiMethod> superMethods, PsiParameter[] parameters, int i) {
+        List<PsiParameter> superParameters = new ArrayList<>();
+        for (PsiMethod superMethod : superMethods) {
+            PsiParameter[] _superParameters = superMethod.getParameterList().getParameters();
+            if (_superParameters.length == parameters.length) {
+                superParameters.add(_superParameters[i]);
             }
+        }
+        return superParameters;
+    }
 
-            checkNullLiteralArgumentOfNotNullParameterUsages(method, holder, nullableManager, isOnFly, i, parameter, state);
+    private void checkSuperParameterAnnotations(ProblemsHolder holder,
+                                                NullableNotNullManager nullableManager,
+                                                PsiParameter parameter,
+                                                List<PsiParameter> superParameters,
+                                                NullableStuffInspectionState state) {
+        PsiIdentifier nameIdentifier = parameter.getNameIdentifier();
+        if (nameIdentifier == null) {
+            return;
+        }
+        PsiParameter nullableSuper = findNullableSuperForNotNullParameter(parameter, superParameters, PsiSubstitutor.EMPTY, state);
+        if (nullableSuper != null) {
+            PsiAnnotation annotation = findAnnotation(parameter, nullableManager.getNotNulls(), true);
+            reportProblem(holder, annotation != null ? annotation : nameIdentifier,
+                "inspection.nullable.problems.NotNull.parameter.overrides.Nullable",
+                getPresentableAnnoName(parameter), getPresentableAnnoName(nullableSuper));
+        }
+        PsiParameter notNullSuper = findNotNullSuperForNonAnnotatedParameter(nullableManager, parameter, superParameters, state);
+        if (notNullSuper != null) {
+            LocalQuickFix fix = isAnnotatingApplicable(parameter, nullableManager.getDefaultAnnotation(Nullability.NOT_NULL, parameter))
+                ? LocalQuickFix.from(AddAnnotationModCommandAction.createAddNotNullFix(parameter))
+                : null;
+            reportProblem(holder, nameIdentifier, fix,
+                "inspection.nullable.problems.parameter.overrides.NotNull", getPresentableAnnoName(notNullSuper));
+        }
+        if (isNotNullParameterOverridingNonAnnotated(nullableManager, parameter, superParameters, PsiSubstitutor.EMPTY, state)) {
+            NullabilityAnnotationInfo info = nullableManager.findEffectiveNullabilityInfo(parameter);
+            assert info != null;
+            PsiAnnotation notNullAnnotation = info.getAnnotation();
+            boolean physical = PsiTreeUtil.isAncestor(parameter, notNullAnnotation, true);
+            LocalQuickFix fix = physical ? new RemoveAnnotationQuickFix(notNullAnnotation, parameter) : null;
+            reportProblem(holder, physical ? notNullAnnotation : nameIdentifier, fix,
+                "inspection.nullable.problems.NotNull.parameter.overrides.not.annotated", getPresentableAnnoName(parameter));
+        }
+
+        PsiTypeElement typeElement = parameter.getTypeElement();
+        if (typeElement != null) {
+            for (PsiParameter superParameter : superParameters) {
+                if (checkNestedGenericClasses(holder, typeElement, parameter.getType(), superParameter.getType(),
+                    ConflictNestedTypeProblem.OVERRIDING_NESTED_TYPE_PROBLEM, state)) {
+                    break;
+                }
+            }
         }
     }
 
-    @Nullable
-    private PsiParameter findNotNullSuperForNonAnnotatedParameter(
-        NullableNotNullManager nullableManager,
-        PsiParameter parameter,
-        List<? extends PsiParameter> superParameters,
-        NullableStuffInspectionState state
-    ) {
-        return state.REPORT_NOT_ANNOTATED_METHOD_OVERRIDES_NOTNULL && !nullableManager.hasNullability(parameter)
-            ? ContainerUtil.find(
-            superParameters,
-            sp -> isNotNullNotInferred(sp, false, state.IGNORE_EXTERNAL_SUPER_NOTNULL) && !hasInheritableNotNull(sp)
-        )
+    private @Nullable PsiParameter findNotNullSuperForNonAnnotatedParameter(NullableNotNullManager nullableManager,
+                                                                            PsiParameter parameter,
+                                                                            List<? extends PsiParameter> superParameters,
+                                                                            NullableStuffInspectionState state) {
+        return state.REPORT_NOT_ANNOTATED_METHOD_OVERRIDES_NOTNULL && !hasNullability(nullableManager, parameter)
+            ? ContainerUtil.find(superParameters,
+            sp -> isNotNullNotInferred(sp, false, state.IGNORE_EXTERNAL_SUPER_NOTNULL) && !hasInheritableNotNull(sp))
             : null;
     }
 
-    @Nullable
-    private PsiParameter findNullableSuperForNotNullParameter(
-        PsiParameter parameter,
-        List<? extends PsiParameter> superParameters,
-        NullableStuffInspectionState state
-    ) {
-        return state.REPORT_NOTNULL_PARAMETER_OVERRIDES_NULLABLE && isNotNullNotInferred(parameter, false, false)
-            ? ContainerUtil.find(superParameters, sp -> isNullableNotInferred(sp, false))
-            : null;
+    private @Nullable PsiParameter findNullableSuperForNotNullParameter(PsiParameter parameter,
+                                                                        List<? extends PsiParameter> superParameters,
+                                                                        PsiSubstitutor superSubstitutor,
+                                                                        NullableStuffInspectionState state) {
+        if (!state.REPORT_NOTNULL_PARAMETER_OVERRIDES_NULLABLE || !isNotNullNotInferred(parameter, false, false)) {
+            return null;
+        }
+        PsiClass derived = PsiUtil.getContainingClass(parameter);
+        for (PsiParameter superParameter : superParameters) {
+            PsiClass base = PsiUtil.getContainingClass(superParameter);
+            PsiSubstitutor substitutor = base == null || derived == null ? PsiSubstitutor.EMPTY :
+                TypeConversionUtil.getMaybeSuperClassSubstitutor(base, derived, superSubstitutor);
+            if (substitutor == null) {
+                // may happen if A extends B implements C and methods are declared in B and C
+                substitutor = superSubstitutor;
+            }
+            PsiType superType = substitutor.substitute(superParameter.getType());
+            if (DfaPsiUtil.getElementNullabilityForRead(superType, superParameter) == Nullability.NULLABLE) {
+                return superParameter;
+            }
+        }
+        return null;
     }
 
-    private boolean isNotNullParameterOverridingNonAnnotated(
-        NullableNotNullManager nullableManager,
-        PsiParameter parameter,
-        List<? extends PsiParameter> superParameters,
-        NullableStuffInspectionState state
-    ) {
+    private boolean isNotNullParameterOverridingNonAnnotated(NullableNotNullManager nullableManager,
+                                                             PsiParameter parameter,
+                                                             List<? extends PsiParameter> superParameters,
+                                                             PsiSubstitutor substitutor,
+                                                             NullableStuffInspectionState state) {
         if (!state.REPORT_NOTNULL_PARAMETERS_OVERRIDES_NOT_ANNOTATED) {
             return false;
         }
-        NullabilityAnnotationInfo info = nullableManager.findOwnNullabilityInfo(parameter);
-        return info != null && info.getNullability() == Nullability.NOT_NULL && !info.isInferred() &&
-            ContainerUtil.exists(superParameters, sp -> !nullableManager.hasNullability(sp));
+        NullabilityAnnotationInfo info = nullableManager.findEffectiveNullabilityInfo(parameter);
+        return info != null && info.getNullability() == Nullability.NOT_NULL && info.getInheritedFrom() == null && !info.isInferred() &&
+            ContainerUtil.exists(superParameters, sp -> isSuperNotAnnotated(nullableManager, parameter, sp, substitutor));
     }
 
-    private void checkNullLiteralArgumentOfNotNullParameterUsages(
-        PsiMethod method,
-        ProblemsHolder holder,
-        NullableNotNullManager nullableManager,
-        boolean isOnFly,
-        int parameterIdx,
-        PsiParameter parameter,
-        NullableStuffInspectionState state
-    ) {
-        if (!state.REPORT_NULLS_PASSED_TO_NOT_NULL_PARAMETER || !isOnFly) {
+    private static boolean isSuperNotAnnotated(NullableNotNullManager nullableManager, PsiParameter parameter,
+                                               PsiParameter superParameter, PsiSubstitutor superSubstitutor) {
+        if (hasNullability(nullableManager, superParameter)) {
+            return false;
+        }
+        if (ContainerUtil.exists(getSuperAnnotationOwners(superParameter),
+            superSuperParameter -> hasNullability(nullableManager, superSuperParameter))) {
+            return false;
+        }
+        PsiType type = superParameter.getType();
+        if (TypeUtils.isTypeParameter(type)) {
+            PsiClass childClass = PsiUtil.getContainingClass(parameter);
+            PsiClass superClass = PsiUtil.getContainingClass(superParameter);
+            if (superClass != null && childClass != null) {
+                PsiSubstitutor substitutor = TypeConversionUtil.getMaybeSuperClassSubstitutor(superClass, childClass, superSubstitutor);
+                if (substitutor == null) {
+                    // may happen if A extends B implements C and methods are declared in B and C
+                    substitutor = superSubstitutor;
+                }
+                PsiType substituted = substitutor.substitute(type);
+                return DfaPsiUtil.getTypeNullability(substituted) == Nullability.UNKNOWN;
+            }
+        }
+        return true;
+    }
+
+    private void checkNullLiteralArgumentOfNotNullParameterUsages(PsiMethod method,
+                                                                  ProblemsHolder holder,
+                                                                  NullableNotNullManager nullableManager,
+                                                                  int parameterIdx,
+                                                                  PsiParameter parameter,
+                                                                  NullableStuffInspectionState state) {
+        if (!state.REPORT_NULLS_PASSED_TO_NOT_NULL_PARAMETER || !holder.isOnTheFly()) {
             return;
         }
 
-        PsiElement elementToHighlight;
-        if (DfaPsiUtil.getTypeNullability(getMemberType(parameter)) == Nullability.NOT_NULL) {
-            elementToHighlight = parameter.getNameIdentifier();
+        PsiVariable owner = parameter.isPhysical() ? parameter : JavaPsiRecordUtil.getComponentForCanonicalConstructorParameter(parameter);
+        if (owner == null) {
+            return;
+        }
+
+        PsiElement elementToHighlight = null;
+        NullabilityAnnotationInfo info = nullableManager.findOwnNullabilityInfo(owner);
+        if (info != null && !info.isInferred()) {
+            if (info.getNullability() == Nullability.NOT_NULL) {
+                PsiAnnotation notNullAnnotation = info.getAnnotation();
+                boolean physical = PsiTreeUtil.isAncestor(owner, notNullAnnotation, true);
+                elementToHighlight = physical ? notNullAnnotation : owner.getNameIdentifier();
+            }
         }
         else {
-            NullabilityAnnotationInfo info = nullableManager.findOwnNullabilityInfo(parameter);
-            if (info == null || info.getNullability() != Nullability.NOT_NULL || info.isInferred()) {
-                return;
+            info = DfaPsiUtil.getTypeNullabilityInfo(owner.getType());
+            if (info != null && info.getNullability() == Nullability.NOT_NULL) {
+                elementToHighlight = owner.getNameIdentifier();
             }
-            PsiAnnotation notNullAnnotation = info.getAnnotation();
-            boolean physical = PsiTreeUtil.isAncestor(parameter, notNullAnnotation, true);
-            elementToHighlight = physical ? notNullAnnotation : parameter.getNameIdentifier();
         }
         if (elementToHighlight == null || !JavaNullMethodArgumentUtil.hasNullArgument(method, parameterIdx)) {
             return;
         }
 
-        holder.newProblem(LocalizeValue.localizeTODO(InspectionsBundle.message(
-                "inspection.nullable.problems.NotNull.parameter.receives.null.literal",
-                getPresentableAnnoName(parameter)
-            )))
-            .range(elementToHighlight)
-            .withFixes(createNavigateToNullParameterUsagesFix(parameter))
-            .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-            .create();
+        reportProblem(holder, elementToHighlight, createNavigateToNullParameterUsagesFix(parameter),
+            "inspection.nullable.problems.NotNull.parameter.receives.null.literal",
+            StringUtil.getShortName(Objects.requireNonNull(info.getAnnotation().getQualifiedName())));
     }
 
-    @RequiredReadAction
-    private void checkOverriders(
-        PsiMethod method,
-        ProblemsHolder holder,
-        Annotated annotated,
-        NullableNotNullManager nullableManager,
-        NullableStuffInspectionState state
-    ) {
+    private void checkOverriders(PsiMethod method,
+                                 ProblemsHolder holder,
+                                 Annotated annotated,
+                                 NullableNotNullManager nullableManager,
+                                 NullableStuffInspectionState state) {
         PsiParameter[] parameters = method.getParameterList().getParameters();
         if (state.REPORT_ANNOTATION_NOT_PROPAGATED_TO_OVERRIDERS) {
             boolean[] checkParameter = new boolean[parameters.length];
@@ -1031,44 +1251,42 @@ private void checkOverriders(
                     !(parameter.getType() instanceof PsiPrimitiveType);
                 hasAnnotatedParameter |= checkParameter[i];
             }
-            boolean checkReturnType =
-                annotated.isDeclaredNotNull && !hasInheritableNotNull(method) && !(method.getReturnType() instanceof PsiPrimitiveType);
+            boolean checkReturnType = annotated.isDeclaredNotNull && !hasInheritableNotNull(method) && !(method.getReturnType() instanceof PsiPrimitiveType);
             if (hasAnnotatedParameter || checkReturnType) {
-                String defaultNotNull = nullableManager.getDefaultNotNull();
-                boolean superMethodApplicable = AnnotationUtil.isAnnotatingApplicable(method, defaultNotNull);
-                PsiMethod[] overridings = OverridingMethodsSearch.search(method).toArray(PsiMethod.EMPTY_ARRAY);
+                PsiMethod[] overridings =
+                    OverridingMethodsSearch.search(method).toArray(PsiMethod.EMPTY_ARRAY);
                 boolean methodQuickFixSuggested = false;
                 for (PsiMethod overriding : overridings) {
                     if (shouldSkipOverriderAsGenerated(overriding)) {
                         continue;
                     }
 
+                    String defaultNotNull = nullableManager.getDefaultAnnotation(Nullability.NOT_NULL, overriding);
                     if (!methodQuickFixSuggested
                         && checkReturnType
                         && !isNotNullNotInferred(overriding, false, false)
                         && (isNullableNotInferred(overriding, false) || !isNullableNotInferred(overriding, true))
                         && AddAnnotationPsiFix.isAvailable(overriding, defaultNotNull)) {
                         PsiIdentifier identifier = method.getNameIdentifier();//load tree
-                        PsiAnnotation annotation = AnnotationUtil.findAnnotation(method, nullableManager.getNotNulls());
-                        String[] annotationsToRemove = ArrayUtil.toStringArray(nullableManager.getNullables());
-
-                        LocalQuickFix fix = AnnotationUtil.isAnnotatingApplicable(overriding, defaultNotNull)
-                            ? new MyAnnotateMethodFix(defaultNotNull, annotationsToRemove)
-                            : superMethodApplicable ? null : createChangeDefaultNotNullFix(nullableManager, method);
-
-                        PsiElement psiElement = annotation;
-                        if (annotation != null && !annotation.isPhysical()) {
-                            psiElement = identifier;
-                        }
-                        if (psiElement == null) {
-                            continue;
+                        NullabilityAnnotationInfo info = nullableManager.findOwnNullabilityInfo(method);
+                        if (info != null) {
+                            PsiAnnotation annotation = info.getAnnotation();
+                            String[] annotationsToRemove = ArrayUtil.toStringArray(nullableManager.getNullables());
+
+                            LocalQuickFix fix = isAnnotatingApplicable(overriding, defaultNotNull)
+                                ? new MyAnnotateMethodFix(Nullability.NOT_NULL, annotationsToRemove)
+                                : null;
+
+                            PsiElement psiElement = annotation;
+                            if (!annotation.isPhysical() || !PsiTreeUtil.isAncestor(method, annotation, true)) {
+                                psiElement = identifier;
+                                if (psiElement == null) {
+                                    continue;
+                                }
+                            }
+                            reportProblem(holder, psiElement, fix, "nullable.stuff.problems.overridden.methods.are.not.annotated");
+                            methodQuickFixSuggested = true;
                         }
-                        holder.newProblem(InspectionLocalize.nullableStuffProblemsOverriddenMethodsAreNotAnnotated())
-                            .range(psiElement)
-                            .withFixes(fix)
-                            .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-                            .create();
-                        methodQuickFixSuggested = true;
                     }
                     if (hasAnnotatedParameter) {
                         PsiParameter[] psiParameters = overriding.getParameterList().getParameters();
@@ -1081,24 +1299,20 @@ private void checkOverriders(
                                 !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;
-                                if (annotation == null || !annotation.isPhysical()) {
+                                PsiIdentifier identifier = parameters[i].getNameIdentifier(); //be sure that corresponding tree element available
+                                NullabilityAnnotationInfo info = nullableManager.findOwnNullabilityInfo(parameters[i]);
+                                PsiElement psiElement = info == null ? null : info.getAnnotation();
+                                if (psiElement == null || !psiElement.isPhysical()) {
                                     psiElement = identifier;
                                     if (psiElement == null) {
                                         continue;
                                     }
                                 }
-                                LocalQuickFix fix = AnnotationUtil.isAnnotatingApplicable(parameter, defaultNotNull)
-                                    ? new AnnotateOverriddenMethodParameterFix(defaultNotNull, nullableManager.getDefaultNullable())
-                                    : createChangeDefaultNotNullFix(nullableManager, parameters[i]);
-                                holder.newProblem(InspectionLocalize.nullableStuffProblemsOverriddenMethodParametersAreNotAnnotated())
-                                    .range(psiElement)
-                                    .withFixes(fix)
-                                    .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-                                    .create();
+                                LocalQuickFix fix = isAnnotatingApplicable(parameter, defaultNotNull)
+                                    ? new AnnotateOverriddenMethodParameterFix(Nullability.NOT_NULL)
+                                    : null;
+                                reportProblem(holder, psiElement, fix,
+                                    "nullable.stuff.problems.overridden.method.parameters.are.not.annotated");
                                 parameterQuickFixSuggested[i] = true;
                             }
                         }
@@ -1108,103 +1322,137 @@ private void checkOverriders(
         }
     }
 
-    @RequiredReadAction
     public static boolean shouldSkipOverriderAsGenerated(PsiMethod overriding) {
-        if (Registry.is("idea.report.nullity.missing.in.generated.overriders", true)) {
+        if (Registry.is("idea.report.nullity.missing.in.generated.overriders")) {
             return false;
         }
 
         PsiFile file = overriding.getContainingFile();
         VirtualFile virtualFile = file != null ? file.getVirtualFile() : null;
-        return virtualFile != null && GeneratedSourcesFilter.isGenerated(overriding.getProject(), virtualFile);
+        return virtualFile != null && GeneratedSourcesFilter.isGeneratedSourceByAnyFilter(virtualFile, overriding.getProject());
     }
 
     private static boolean isNotNullNotInferred(PsiModifierListOwner owner, boolean checkBases, boolean skipExternal) {
         Project project = owner.getProject();
         NullableNotNullManager manager = NullableNotNullManager.getInstance(project);
         NullabilityAnnotationInfo info = manager.findEffectiveNullabilityInfo(owner);
-        return info != null && !info.isInferred() && info.getNullability() == Nullability.NOT_NULL
-            && (checkBases || info.getInheritedFrom() == null)
-            && (!skipExternal || !info.isExternal());
+        if (info == null || info.isInferred() || info.getNullability() != Nullability.NOT_NULL) {
+            return false;
+        }
+        if (!checkBases && info.getInheritedFrom() != null) {
+            return false;
+        }
+        if (skipExternal && info.isExternal()) {
+            return false;
+        }
+        return true;
     }
 
     public static boolean isNullableNotInferred(PsiModifierListOwner owner, boolean checkBases) {
         Project project = owner.getProject();
         NullableNotNullManager manager = NullableNotNullManager.getInstance(project);
         NullabilityAnnotationInfo info = manager.findEffectiveNullabilityInfo(owner);
-        return info != null && !info.isInferred() && info.getNullability() == Nullability.NULLABLE
-            && (checkBases || info.getInheritedFrom() == null);
+        return info != null && !info.isInferred() && info.getNullability() == Nullability.NULLABLE &&
+            (checkBases || info.getInheritedFrom() == null);
     }
 
-    private static PsiType getMemberType(PsiModifierListOwner owner) {
-        return owner instanceof PsiMethod method ? method.getReturnType() : owner instanceof PsiVariable variable ? variable.getType() : null;
-    }
+    private static class MyAnnotateMethodFix implements LocalQuickFix {
+        private Nullability myNullability;
+        private String[] myAnnotationsToRemove;
+
+        MyAnnotateMethodFix(Nullability nullability, String ... annotationsToRemove) {
+            myNullability = nullability;
+            myAnnotationsToRemove = annotationsToRemove.length == 0 ? ArrayUtil.EMPTY_STRING_ARRAY : annotationsToRemove;
+        }
+
+        @Override
+        public String getFamilyName() {
+            return JavaAnalysisBundle.message("inspection.annotate.overridden.method.quickfix.family.name");
+        }
+
+        @Override
+        public boolean startInWriteAction() {
+            return false;
+        }
+
+        @Override
+        public void applyFix(Project project, ProblemDescriptor descriptor) {
+            PsiElement psiElement = descriptor.getPsiElement();
+
+            PsiMethod method = PsiTreeUtil.getParentOfType(psiElement, PsiMethod.class);
+            if (method == null) {
+                return;
+            }
+            List<PsiMethod> toAnnotate = new ArrayList<>();
+            NullableNotNullManager manager = NullableNotNullManager.getInstance(project);
 
-    private static LocalQuickFix createChangeDefaultNotNullFix(
-        NullableNotNullManager nullableManager,
-        PsiModifierListOwner modifierListOwner
-    ) {
-        PsiAnnotation annotation = AnnotationUtil.findAnnotation(modifierListOwner, nullableManager.getNotNulls());
-        if (annotation != null) {
-            PsiJavaCodeReferenceElement referenceElement = annotation.getNameReferenceElement();
-            if (referenceElement != null) {
-                JavaResolveResult resolveResult = referenceElement.advancedResolve(false);
-                if (resolveResult.getElement() != null
-                    && resolveResult.isValidResult()
-                    && !nullableManager.getDefaultNotNull().equals(annotation.getQualifiedName())) {
-                    return new ChangeNullableDefaultsFix(annotation.getQualifiedName(), null, nullableManager);
+            if (!AnnotateOverriddenMethodParameterFix.processModifiableInheritorsUnderProgress(method, (Consumer<? super PsiMethod>) psiMethod -> {
+                NullabilityAnnotationInfo info = manager.findEffectiveNullabilityInfo(psiMethod);
+                if (info != null && info.getNullability() == myNullability && !info.isInferred() && info.getInheritedFrom() == null) {
+                    return;
                 }
+                String annotation = manager.getDefaultAnnotation(myNullability, psiMethod);
+                if (isAnnotatingApplicable(psiMethod, annotation) &&
+                    !isAnnotated(psiMethod, annotation, CHECK_EXTERNAL | CHECK_TYPE)) {
+                    toAnnotate.add(psiMethod);
+                }
+            })) {
+                return;
             }
+
+            FileModificationService.getInstance().preparePsiElementsForWrite(toAnnotate);
+            for (PsiMethod psiMethod : toAnnotate) {
+                String annotation = manager.getDefaultAnnotation(myNullability, psiMethod);
+                AddAnnotationPsiFix fix = new AddAnnotationPsiFix(annotation, psiMethod, myAnnotationsToRemove);
+                fix.invoke(psiMethod.getProject(), psiMethod.getContainingFile(), psiMethod, psiMethod);
+            }
+            LanguageUndoUtil.markPsiFileForUndo(method.getContainingFile());
         }
-        return null;
-    }
 
-    private static void reportNullableNotNullConflict(
-        ProblemsHolder holder,
-        PsiModifierListOwner listOwner,
-        PsiAnnotation declaredNullable,
-        PsiAnnotation declaredNotNull
-    ) {
-        LocalizeValue bothNullableNotNullMessage = LocalizeValue.localizeTODO(InspectionsBundle.message(
-            "inspection.nullable.problems.Nullable.NotNull.conflict",
-            getPresentableAnnoName(declaredNullable),
-            getPresentableAnnoName(declaredNotNull)
-        ));
-        holder.newProblem(bothNullableNotNullMessage)
-            .range(declaredNotNull.isPhysical() ? declaredNotNull : listOwner.getNavigationElement())
-            .withFixes(new RemoveAnnotationQuickFix(declaredNotNull, listOwner))
-            .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-            .create();
-        holder.newProblem(bothNullableNotNullMessage)
-            .range(declaredNullable.isPhysical() ? declaredNullable : listOwner.getNavigationElement())
-            .withFixes(new RemoveAnnotationQuickFix(declaredNullable, listOwner))
-            .highlightType(ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
-            .create();
+        @Override
+        public String getName() {
+            return JavaAnalysisBundle.message("inspection.annotate.overridden.method.nullable.quickfix.name");
+        }
     }
 
-    @Override
-    public NullableStuffInspectionState createStateProvider() {
-        return new NullableStuffInspectionState();
-    }
 
-    private static class MyAnnotateMethodFix extends AnnotateMethodFix {
-        MyAnnotateMethodFix(String defaultNotNull, String[] annotationsToRemove) {
-            super(defaultNotNull, annotationsToRemove);
+    private enum ConflictNestedTypeProblem {
+        RETURN_NESTED_TYPE_PROBLEM("returning.a.class.with.notnull.arguments", "returning.a.class.with.nullable.arguments"),
+        ASSIGNMENT_NESTED_TYPE_PROBLEM("assigning.a.class.with.notnull.elements", "assigning.a.class.with.nullable.elements"),
+        OVERRIDING_NESTED_TYPE_PROBLEM("overriding.a.class.with.notnull.elements", "overriding.a.class.with.nullable.elements"),
+        ;
+
+        @NotNull
+        @PropertyKey(resourceBundle = JavaAnalysisBundle.BUNDLE)
+        private String notNullToNullProblemMessage;
+
+        @NotNull
+        @PropertyKey(resourceBundle = JavaAnalysisBundle.BUNDLE)
+        private String nullToNotNullProblemMessage;
+        @NotNull
+        @PropertyKey(resourceBundle = JavaAnalysisBundle.BUNDLE)
+        private String complexProblem;
+
+        ConflictNestedTypeProblem(@PropertyKey(resourceBundle = JavaAnalysisBundle.BUNDLE) String notNullToNullProblemMessage,
+                                  @PropertyKey(resourceBundle = JavaAnalysisBundle.BUNDLE) String nullToNotNullProblemMessage) {
+            this.notNullToNullProblemMessage = notNullToNullProblemMessage;
+            this.nullToNotNullProblemMessage = nullToNotNullProblemMessage;
+            this.complexProblem = "complex.problem.with.nullability";
         }
 
-        @Override
-        protected String getPreposition() {
-            return "as";
+        @NotNull
+        String notNullToNullProblem() {
+            return notNullToNullProblemMessage;
         }
 
-        @Override
-        protected boolean annotateOverriddenMethods() {
-            return true;
+        @NotNull
+        String nullToNotNullProblem() {
+            return nullToNotNullProblemMessage;
         }
 
-        @Override
-        protected boolean annotateSelf() {
-            return false;
+        @NotNull
+        String complexProblem() {
+            return complexProblem;
         }
     }
-}
+}
\ No newline at end of file
diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/nullable/NullableStuffInspectionState.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/nullable/NullableStuffInspectionState.java
index 5df5fedfd2..4d51da2ad8 100644
--- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/nullable/NullableStuffInspectionState.java
+++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/nullable/NullableStuffInspectionState.java
@@ -41,6 +41,12 @@ public class NullableStuffInspectionState implements InspectionToolState<Nullabl
   public boolean REPORT_NULLS_PASSED_TO_NON_ANNOTATED_METHOD = true;
   public boolean REPORT_NULLS_PASSED_TO_NOT_NULL_PARAMETER = true;
 
+  public boolean REPORT_NULLABILITY_ANNOTATION_ON_LOCALS = true;
+  public boolean REPORT_NOT_NULL_TO_NULLABLE_CONFLICTS_IN_ASSIGNMENTS = false;
+  public boolean REPORT_NOT_ANNOTATED_INSTANTIATION_NOT_NULL_TYPE = false;
+
+  public boolean REPORT_REDUNDANT_NULLABILITY_ANNOTATION_IN_THE_SCOPE_OF_ANNOTATED_CONTAINER = true;
+
   @Nullable
   @Override
   public UnnamedConfigurable createConfigurable() {
diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/nullable/NullableStuffInspectionUtil.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/nullable/NullableStuffInspectionUtil.java
new file mode 100644
index 0000000000..bf299671cd
--- /dev/null
+++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/nullable/NullableStuffInspectionUtil.java
@@ -0,0 +1,213 @@
+// Copyright 2000-2025 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
+package com.intellij.java.analysis.impl.codeInspection.nullable;
+
+import com.intellij.java.analysis.JavaAnalysisBundle;
+import com.intellij.java.language.psi.*;
+import com.intellij.java.language.util.JavaTypeNullabilityUtil;
+import consulo.application.util.HtmlChunk;
+import consulo.language.psi.PsiElement;
+import consulo.language.psi.util.PsiTreeUtil;
+import consulo.util.collection.ArrayUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+final class NullableStuffInspectionUtil {
+    static @NotNull HtmlChunk getNullabilityConflictPresentation(@NotNull JavaTypeNullabilityUtil.NullabilityConflictContext context) {
+        HtmlChunk expectedChunk = getSideChunk(context, JavaTypeNullabilityUtil.Side.EXPECTED);
+        HtmlChunk actualChunk = getSideChunk(context, JavaTypeNullabilityUtil.Side.ACTUAL);
+        if (expectedChunk.isEmpty() || actualChunk.isEmpty()) return HtmlChunk.empty();
+        return HtmlChunk.tag("table")
+            .children(expectedChunk, actualChunk);
+    }
+
+    private static @NotNull HtmlChunk getSideChunk(@NotNull JavaTypeNullabilityUtil.NullabilityConflictContext context,
+                                                   @NotNull JavaTypeNullabilityUtil.Side side) {
+        PsiElement place = context.getPlace(side);
+        if (place == null) return HtmlChunk.empty();
+        int dimensionsInArray = (context.getType(side) instanceof PsiArrayType type) ? type.getArrayDimensions() : 0;
+
+        PsiTypeElement topmostType = PsiTreeUtil.getTopmostParentOfType(place, PsiTypeElement.class);
+        if (topmostType == null) return HtmlChunk.empty();
+
+        PsiTypeElement target = PsiTreeUtil.getParentOfType(place, PsiTypeElement.class, false);
+        if (target == null) return HtmlChunk.empty();
+
+        PsiType outerType = topmostType.getType();
+        if (target == topmostType) {
+            // Presentation is not handling with the whole type
+            return HtmlChunk.empty();
+        }
+
+        List<Integer> path = computeTypeArgumentPath(topmostType, target, dimensionsInArray);
+        if (path == null) return HtmlChunk.empty();
+
+        Context presentationContext = getPresentationContext(outerType, path, outerType instanceof PsiArrayType);
+
+        String typeText = presentationContext.sb.toString();
+        String annotationText = getAnnotationText(context, side);
+        if (presentationContext.position == null || annotationText == null) return HtmlChunk.empty();
+        HtmlChunk result = generateHtmlChunk(typeText, "@" + annotationText, side, presentationContext.position);
+        return result;
+    }
+
+    private static @Nullable String getAnnotationText(@NotNull JavaTypeNullabilityUtil.NullabilityConflictContext context, @NotNull JavaTypeNullabilityUtil.Side side) {
+        PsiAnnotation annotation = context.getAnnotation(side);
+        if (annotation == null) return null;
+        PsiJavaCodeReferenceElement ref = annotation.getNameReferenceElement();
+        if (ref == null) return null;
+        return ref.getReferenceName();
+    }
+
+    private static @NotNull HtmlChunk generateHtmlChunk(String text,
+                                                        String annotationText,
+                                                        JavaTypeNullabilityUtil.Side side,
+                                                        int position) {
+        return HtmlChunk.tag("tr")
+            .children(
+                HtmlChunk.tag("td")
+                    .addText(
+                        JavaAnalysisBundle.message(
+                            side == JavaTypeNullabilityUtil.Side.EXPECTED ? "expected.type.nullability.conflict.message"
+                                : "actual.type.nullability.conflict.message"
+                        )
+                    ),
+                HtmlChunk.tag("td").children(
+                    HtmlChunk.text(text.substring(0, position)),
+                    HtmlChunk.tag("b").addText(annotationText),
+                    HtmlChunk.text(" "),
+                    HtmlChunk.text(text.substring(position))
+                )
+            );
+    }
+
+    private static @Nullable List<@NotNull Integer> computeTypeArgumentPath(@NotNull PsiTypeElement top, @NotNull PsiTypeElement target, int firstArrayDepth) {
+        List<Integer> indices = new ArrayList<>();
+        PsiTypeElement current = target;
+        boolean isFirstArrayOccurence = true;
+        while (true) {
+            PsiTypeElement parentTypeElement = PsiTreeUtil.getParentOfType(current, PsiTypeElement.class, true);
+            if (parentTypeElement == null) return null;
+            PsiType parentType = parentTypeElement.getType();
+            if (parentType instanceof PsiClassType) {
+                PsiJavaCodeReferenceElement ref = parentTypeElement.getInnermostComponentReferenceElement();
+                if (ref == null) return null;
+                PsiReferenceParameterList params = ref.getParameterList();
+                if (params == null) return null;
+                PsiTypeElement[] args = params.getTypeParameterElements();
+                int found = ArrayUtil.indexOf(args, current);
+                if (found < 0) return null;
+                indices.add(found);
+            }
+            else if (parentType instanceof PsiWildcardType ||
+                parentType instanceof PsiCapturedWildcardType) {
+                indices.add(0);
+            }
+            else if (parentType instanceof PsiArrayType arrayType) {
+                int candidateArrayDepth = arrayType.getArrayDimensions();
+                int numberToAdd;
+                if (isFirstArrayOccurence && candidateArrayDepth == firstArrayDepth) {
+                    numberToAdd = 0;
+                }
+                else if (isFirstArrayOccurence && firstArrayDepth > 0) {
+                    numberToAdd = firstArrayDepth;
+                }
+                else {
+                    numberToAdd = candidateArrayDepth;
+                }
+                for (int i = 0; i < numberToAdd; i++) {
+                    indices.add(0);
+                }
+            }
+            if (parentTypeElement == top) break;
+            current = parentTypeElement;
+            isFirstArrayOccurence = false;
+        }
+        Collections.reverse(indices);
+        return indices;
+    }
+
+    private static @NotNull Context getPresentationContext(@NotNull PsiType type, List<Integer> path, boolean isInsideArray) {
+        Context context = new Context();
+        buildTextRepresentation(type, context, path, 0, isInsideArray);
+        return context;
+    }
+
+    /**
+     * Constructs the simplified presentable view of the type and detects the place in which the nullability annotation should be inserted.
+     * The result of this method is stored in the {@link Context#sb} member.
+     *
+     * @param isInsideArray corresponds to the state whether the method is called within the array dimension. It is used to distinguish
+     *                      cases {@code @Nullable String[]} and {@code String @Nullable [][]}.
+     */
+    private static void buildTextRepresentation(@NotNull PsiType type,
+                                                @NotNull Context context,
+                                                @NotNull List<@NotNull Integer> path,
+                                                int depth,
+                                                boolean isInsideArray) {
+        if (depth == path.size()) {
+            if (type instanceof PsiArrayType arrayType && isInsideArray) {
+                context.sb.append(arrayType.getPresentableText(false));
+                context.sb.append(" ");
+                context.position = context.sb.length();
+            }
+            else if (type instanceof PsiArrayType arrayType) {
+                context.sb.append(arrayType.getDeepComponentType().getPresentableText(false));
+                context.sb.append(" ");
+                context.position = context.sb.length();
+                context.sb.repeat("[]", Math.max(0, arrayType.getArrayDimensions()));
+            }
+            else {
+                String text = type.getPresentableText(false);
+                context.position = context.sb.length();
+                context.sb.append(text);
+            }
+            return;
+        }
+        if (type instanceof PsiArrayType arrayType) {
+            PsiType component = arrayType.getComponentType();
+            buildTextRepresentation(component, context, path, depth + 1, true);
+            context.sb.append("[]");
+            return;
+        }
+        if (type instanceof PsiWildcardType wc) {
+            String prefix = wc.isExtends() ? "? extends " : wc.isSuper() ? "? super " : "?";
+            context.sb.append(prefix);
+            PsiType bound = wc.getBound();
+            if (bound != null) {
+                buildTextRepresentation(bound, context, path, depth + 1, false);
+            }
+            return;
+        }
+        if (type instanceof PsiClassType cls) {
+            String name = cls.getClassName();
+            if (name == null) name = cls.getPresentableText(false);
+            context.sb.append(name);
+            PsiType[] params = cls.getParameters();
+            if (params.length > 0) {
+                context.sb.append('<');
+                for (int i = 0; i < params.length; i++) {
+                    if (i > 0) context.sb.append(", ");
+                    if (i == path.get(depth)) {
+                        buildTextRepresentation(params[i], context, path, depth + 1, false);
+                    }
+                    else {
+                        context.sb.append(params[i].getPresentableText(false));
+                    }
+                }
+                context.sb.append('>');
+            }
+            return;
+        }
+
+        context.sb.append(type.getPresentableText(false));
+    }
+
+    private static final class Context {
+        private @Nullable Integer position = null;
+        private final @NotNull StringBuilder sb = new StringBuilder();
+    }
+}
diff --git a/java-language-api/src/main/java/com/intellij/java/language/annoPackages/AnnotationPackageSupport.java b/java-language-api/src/main/java/com/intellij/java/language/annoPackages/AnnotationPackageSupport.java
index c00cf546d1..8faa5bd7c6 100644
--- a/java-language-api/src/main/java/com/intellij/java/language/annoPackages/AnnotationPackageSupport.java
+++ b/java-language-api/src/main/java/com/intellij/java/language/annoPackages/AnnotationPackageSupport.java
@@ -86,4 +86,12 @@ default boolean isTypeUseAnnotationLocationRestricted() {
     default boolean canAnnotateLocals() {
         return true;
     }
+
+    /**
+     * @return true if the non-null annotation reported by this support is used for the instrumentation or code generation.
+     * In this case, it won't be reported as redundant if it appears in the scope of container non-null annotation.
+     */
+    default boolean isNonNullUsedForInstrumentation() {
+        return false;
+    }
 }
diff --git a/java-language-api/src/main/java/com/intellij/java/language/codeInsight/AnnotationUtil.java b/java-language-api/src/main/java/com/intellij/java/language/codeInsight/AnnotationUtil.java
index f1d913fb66..5e2b4b184e 100644
--- a/java-language-api/src/main/java/com/intellij/java/language/codeInsight/AnnotationUtil.java
+++ b/java-language-api/src/main/java/com/intellij/java/language/codeInsight/AnnotationUtil.java
@@ -3,6 +3,7 @@
  */
 package com.intellij.java.language.codeInsight;
 
+import com.intellij.java.language.JavaFeature;
 import com.intellij.java.language.psi.*;
 import com.intellij.java.language.psi.util.InheritanceUtil;
 import com.intellij.java.language.psi.util.PsiUtil;
@@ -21,9 +22,10 @@
 import consulo.util.collection.ArrayUtil;
 import consulo.util.collection.ContainerUtil;
 import consulo.util.lang.Comparing;
-import org.jspecify.annotations.Nullable;
+import consulo.util.lang.ObjectUtil;
 import org.intellij.lang.annotations.MagicConstant;
 import org.jetbrains.annotations.Contract;
+import org.jspecify.annotations.Nullable;
 
 import java.lang.annotation.Annotation;
 import java.lang.annotation.ElementType;
@@ -39,817 +41,870 @@
  */
 public class AnnotationUtil {
 
-  public static final class AnnotationAndOwner {
-    final PsiModifierListOwner owner;
-    final PsiAnnotation annotation;
-
-    AnnotationAndOwner(PsiModifierListOwner owner, PsiAnnotation annotation) {
-      this.owner = owner;
-      this.annotation = annotation;
-    }
-  }
-
-  @Deprecated
-  @DeprecationInfo("JB NotNull annotations is not used anymore. Use jakarta annotations")
-  public static final String NULLABLE = "org.jetbrains.annotations.Nullable";
-  @Deprecated
-  @DeprecationInfo("JB NotNull annotations is not used anymore. Use jakarta annotations")
-  public static final String NOT_NULL = "org.jetbrains.annotations.NotNull";
-
-  public static final String NON_NLS = "org.jetbrains.annotations.NonNls";
-  public static final String NLS = "org.jetbrains.annotations.Nls";
-
-  public static final String PROPERTY_KEY = "org.jetbrains.annotations.PropertyKey";
-  public static final String PROPERTY_KEY_RESOURCE_BUNDLE_PARAMETER = "resourceBundle";
-
-  public static final String TEST_ONLY = "org.jetbrains.annotations.TestOnly";
-
-  public static final String LANGUAGE = "org.intellij.lang.annotations.Language";
-
-  @Nullable
-  static AnnotationAndOwner findAnnotationAndOwnerInHierarchy(PsiModifierListOwner listOwner,
-                                                              Set<String> annotationNames,
-                                                              boolean skipExternal) {
-    PsiAnnotation directAnnotation = findAnnotation(listOwner, annotationNames, skipExternal);
-    if (directAnnotation != null) return new AnnotationAndOwner(listOwner, directAnnotation);
-
-    for (PsiModifierListOwner superOwner : getSuperAnnotationOwners(listOwner)) {
-      PsiAnnotation annotation = findAnnotation(superOwner, annotationNames, skipExternal);
-      if (annotation != null) {
-        return new AnnotationAndOwner(superOwner, annotation);
-      }
-    }
-    return null;
-  }
-
-  @Nullable
-  public static PsiAnnotation findAnnotation(@Nullable PsiModifierListOwner listOwner, String... annotationNames) {
-    return findAnnotation(listOwner, false, annotationNames);
-  }
-
-  @Nullable
-  public static PsiAnnotation findAnnotation(@Nullable PsiModifierListOwner listOwner,
-                                             boolean skipExternal,
-                                             String... annotationNames) {
-    if (annotationNames.length == 0) {
-      return null;
-    }
-    Set<String> set = annotationNames.length == 1 ? Collections.singleton(annotationNames[0]) : Set.of(annotationNames);
-    return findAnnotation(listOwner, set, skipExternal);
-  }
-
-  @Nullable
-  public static PsiAnnotation findAnnotation(@Nullable PsiModifierListOwner listOwner, Set<String> annotationNames) {
-    return findAnnotation(listOwner, (Collection<String>)annotationNames);
-  }
-
-  @Nullable
-  public static PsiAnnotation findAnnotation(@Nullable PsiModifierListOwner listOwner, Collection<String> annotationNames) {
-    return findAnnotation(listOwner, annotationNames, false);
-  }
-
-  @Nullable
-  public static PsiAnnotation findAnnotation(@Nullable PsiModifierListOwner listOwner,
-                                             Collection<String> annotationNames,
-                                             boolean skipExternal) {
-    if (listOwner == null) {
-      return null;
-    }
-
-    PsiAnnotation annotation = findOwnAnnotation(listOwner, annotationNames);
-    if (annotation != null) {
-      return annotation;
-    }
-    return skipExternal ? null : findNonCodeAnnotation(listOwner, annotationNames);
-  }
-
-  private static PsiAnnotation findOwnAnnotation(final PsiModifierListOwner listOwner, Collection<String> annotationNames) {
-    Map<Collection<String>, PsiAnnotation> map = LanguageCachedValueUtil.getCachedValue(listOwner, () ->
-    {
-      Map<Collection<String>, PsiAnnotation> value = ConcurrentFactoryMap.createMap(annotationNames1 ->
-                                                                                    {
-                                                                                      final PsiModifierList list =
-                                                                                        listOwner.getModifierList();
-                                                                                      if (list == null) {
-                                                                                        return null;
-                                                                                      }
-                                                                                      for (PsiAnnotation annotation : list.getAnnotations()) {
-                                                                                        if (annotationNames1.contains(annotation.getQualifiedName())) {
-                                                                                          return annotation;
-                                                                                        }
-                                                                                      }
-                                                                                      return null;
-                                                                                    });
-      return CachedValueProvider.Result.create(value, PsiModificationTracker.MODIFICATION_COUNT);
-    });
-    return map.get(annotationNames);
-  }
-
-  private static PsiAnnotation findNonCodeAnnotation(final PsiModifierListOwner listOwner, Collection<String> annotationNames) {
-    Map<Collection<String>, PsiAnnotation> map = LanguageCachedValueUtil.getCachedValue(listOwner, () ->
-    {
-      Map<Collection<String>, PsiAnnotation> value = ConcurrentFactoryMap.createMap(annotationNames1 ->
-                                                                                    {
-                                                                                      PsiUtilCore.ensureValid(listOwner);
-                                                                                      final Project project = listOwner.getProject();
-                                                                                      final ExternalAnnotationsManager annotationsManager =
-                                                                                        ExternalAnnotationsManager.getInstance(project);
-                                                                                      for (String annotationName : annotationNames1) {
-                                                                                        final PsiAnnotation annotation =
-                                                                                          annotationsManager.findExternalAnnotation(
-                                                                                            listOwner,
-                                                                                            annotationName);
-                                                                                        if (annotation != null) {
-                                                                                          return annotation;
-                                                                                        }
-                                                                                      }
-                                                                                      final InferredAnnotationsManager
-                                                                                        inferredAnnotationsManager =
-                                                                                        InferredAnnotationsManager.getInstance(project);
-                                                                                      for (String annotationName : annotationNames1) {
-                                                                                        final PsiAnnotation annotation =
-                                                                                          inferredAnnotationsManager.findInferredAnnotation(
-                                                                                            listOwner,
-                                                                                            annotationName);
-                                                                                        if (annotation != null) {
-                                                                                          return annotation;
-                                                                                        }
-                                                                                      }
-                                                                                      return null;
-
-                                                                                    });
-      return CachedValueProvider.Result.create(value, PsiModificationTracker.MODIFICATION_COUNT);
-    });
-    return map.get(annotationNames);
-  }
-
-  public static PsiAnnotation[] findAnnotations(@Nullable PsiModifierListOwner modifierListOwner,
-                                                Collection<String> annotationNames) {
-    if (modifierListOwner == null) {
-      return PsiAnnotation.EMPTY_ARRAY;
-    }
-    final PsiModifierList modifierList = modifierListOwner.getModifierList();
-    if (modifierList == null) {
-      return PsiAnnotation.EMPTY_ARRAY;
-    }
-    final PsiAnnotation[] annotations = modifierList.getAnnotations();
-    ArrayList<PsiAnnotation> result = null;
-    for (final PsiAnnotation psiAnnotation : annotations) {
-      if (annotationNames.contains(psiAnnotation.getQualifiedName())) {
-        if (result == null) {
-          result = new ArrayList<>();
-        }
-        result.add(psiAnnotation);
-      }
-    }
-    return result == null ? PsiAnnotation.EMPTY_ARRAY : result.toArray(new PsiAnnotation[result.size()]);
-  }
-
-  public static <T extends PsiModifierListOwner> List<T> getSuperAnnotationOwners(T element) {
-    return LanguageCachedValueUtil.getCachedValue(element, () ->
-    {
-      Set<PsiModifierListOwner> result = new LinkedHashSet<>();
-      if (element instanceof PsiMethod) {
-        collectSuperMethods(result,
-                            ((PsiMethod)element).getHierarchicalMethodSignature(),
-                            element,
-                            JavaPsiFacade.getInstance(element.getProject()).getResolveHelper());
-      }
-      else if (element instanceof PsiClass) {
-        //noinspection unchecked
-        InheritanceUtil.processSupers((PsiClass)element, false, (Processor)Processors.cancelableCollectProcessor(result));
-      }
-      else if (element instanceof PsiParameter) {
-        collectSuperParameters(result, (PsiParameter)element);
-      }
-
-      //noinspection unchecked
-      List<T> list = new ArrayList<>((Collection<? extends T>)result);
-
-      return CachedValueProvider.Result.create(list, PsiModificationTracker.MODIFICATION_COUNT);
-    });
-  }
-
-
-  @Nullable
-  public static PsiAnnotation findAnnotationInHierarchy(final PsiModifierListOwner listOwner,
-                                                        Set<String> annotationNames, boolean skipExternal) {
-    PsiAnnotation directAnnotation = findAnnotation(listOwner, annotationNames, skipExternal);
-    if (directAnnotation != null)
-      return directAnnotation;
-
-    for (PsiModifierListOwner superOwner : getSuperAnnotationOwners(listOwner)) {
-      PsiAnnotation annotation = findAnnotation(superOwner, annotationNames, skipExternal);
-      if (annotation != null) {
-        return annotation;
-      }
-    }
-    return null;
-  }
-
-  @Nullable
-  public static PsiAnnotation findAnnotationInHierarchy(final PsiModifierListOwner listOwner,
-                                                        Set<String> annotationNames) {
-    return findAnnotationInHierarchy(listOwner, annotationNames, false);
-  }
-
-  private static void collectSuperParameters(final Set<PsiModifierListOwner> result, PsiParameter parameter) {
-    PsiElement parent = parameter.getParent();
-    if (!(parent instanceof PsiParameterList)) {
-      return;
-    }
-    final int index = ((PsiParameterList)parent).getParameterIndex(parameter);
-    Consumer<PsiMethod> forEachSuperMethod = method ->
-    {
-      PsiParameter[] superParameters = method.getParameterList().getParameters();
-      if (index < superParameters.length) {
-        result.add(superParameters[index]);
-      }
-    };
+    public static final class AnnotationAndOwner {
+        final PsiModifierListOwner owner;
+        final PsiAnnotation annotation;
 
-    PsiElement scope = parent.getParent();
-    if (scope instanceof PsiLambdaExpression) {
-      PsiMethod method = LambdaUtil.getFunctionalInterfaceMethod(((PsiLambdaExpression)scope).getFunctionalInterfaceType());
-      if (method != null) {
-        forEachSuperMethod.accept(method);
-        for (PsiMethod superMethod : getSuperAnnotationOwners(method)) {
-          forEachSuperMethod.accept(superMethod);
-        }
-      }
-    }
-    else if (scope instanceof PsiMethod) {
-      for (PsiMethod superMethod : getSuperAnnotationOwners((PsiMethod)scope)) {
-        forEachSuperMethod.accept(superMethod);
-      }
-    }
-  }
-
-  private static void collectSuperMethods(Set<PsiModifierListOwner> result,
-                                          HierarchicalMethodSignature signature,
-                                          PsiElement place,
-                                          PsiResolveHelper resolveHelper) {
-    for (final HierarchicalMethodSignature superSignature : signature.getSuperSignatures()) {
-      final PsiMethod superMethod = superSignature.getMethod();
-      if (!resolveHelper.isAccessible(superMethod, place, null)) {
-        continue;
-      }
-      if (!result.add(superMethod)) {
-        continue;
-      }
-      collectSuperMethods(result, superSignature, place, resolveHelper);
-    }
-  }
-
-  public static final int CHECK_HIERARCHY = 0x01;
-  public static final int CHECK_EXTERNAL = 0x02;
-  public static final int CHECK_INFERRED = 0x04;
-  public static final int CHECK_TYPE = 0x08;
-
-  @MagicConstant(flags = {
-    CHECK_HIERARCHY,
-    CHECK_EXTERNAL,
-    CHECK_INFERRED,
-    CHECK_TYPE
-  })
-  @Target({
-    ElementType.PARAMETER,
-    ElementType.METHOD
-  })
-  private @interface Flags {
-  }
-
-  public static boolean isAnnotated(PsiModifierListOwner listOwner, Collection<String> annotations, @Flags int flags) {
-    return annotations.stream().anyMatch(annotation -> isAnnotated(listOwner, annotation, flags, null));
-  }
-
-  public static boolean isAnnotated(PsiModifierListOwner listOwner, String annotationFqn, @Flags int flags) {
-    return isAnnotated(listOwner, annotationFqn, flags, null);
-  }
-
-  private static boolean isAnnotated(PsiModifierListOwner listOwner, String annotationFQN, int flags, @Nullable Set<PsiMember> processed) {
-    if (!listOwner.isValid()) {
-      return false;
-    }
-
-    PsiModifierList modifierList = listOwner.getModifierList();
-    if (modifierList == null) {
-      return false;
-    }
-
-    PsiAnnotation annotation = modifierList.findAnnotation(annotationFQN);
-    if (annotation != null) {
-      return true;
-    }
-
-    if (isSet(flags, CHECK_TYPE)) {
-      PsiType type = null;
-      if (listOwner instanceof PsiMethod) {
-        type = ((PsiMethod)listOwner).getReturnType();
-      }
-      else if (listOwner instanceof PsiVariable) {
-        type = ((PsiVariable)listOwner).getType();
-      }
-      if (type != null && type.findAnnotation(annotationFQN) != null) {
-        return true;
-      }
+        AnnotationAndOwner(PsiModifierListOwner owner, PsiAnnotation annotation) {
+            this.owner = owner;
+            this.annotation = annotation;
+        }
     }
 
-    if (isSet(flags, CHECK_EXTERNAL)) {
-      Project project = listOwner.getProject();
-      if (ExternalAnnotationsManager.getInstance(project).findExternalAnnotation(listOwner, annotationFQN) != null) {
-        return true;
-      }
+    @Deprecated
+    @DeprecationInfo("JB NotNull annotations is not used anymore. Use jakarta annotations")
+    public static final String NULLABLE = "org.jetbrains.annotations.Nullable";
+    @Deprecated
+    @DeprecationInfo("JB NotNull annotations is not used anymore. Use jakarta annotations")
+    public static final String NOT_NULL = "org.jetbrains.annotations.NotNull";
+
+    public static final String NON_NLS = "org.jetbrains.annotations.NonNls";
+    public static final String NLS = "org.jetbrains.annotations.Nls";
+
+    public static final String PROPERTY_KEY = "org.jetbrains.annotations.PropertyKey";
+    public static final String PROPERTY_KEY_RESOURCE_BUNDLE_PARAMETER = "resourceBundle";
+
+    public static final String TEST_ONLY = "org.jetbrains.annotations.TestOnly";
+
+    public static final String LANGUAGE = "org.intellij.lang.annotations.Language";
+
+    public static final String UNKNOWN_NULLABILITY = "org.jetbrains.annotations.UnknownNullability";
+
+    @Nullable
+    static AnnotationAndOwner findAnnotationAndOwnerInHierarchy(PsiModifierListOwner listOwner,
+                                                                Set<String> annotationNames,
+                                                                boolean skipExternal) {
+        PsiAnnotation directAnnotation = findAnnotation(listOwner, annotationNames, skipExternal);
+        if (directAnnotation != null) {
+            return new AnnotationAndOwner(listOwner, directAnnotation);
+        }
+
+        for (PsiModifierListOwner superOwner : getSuperAnnotationOwners(listOwner)) {
+            PsiAnnotation annotation = findAnnotation(superOwner, annotationNames, skipExternal);
+            if (annotation != null) {
+                return new AnnotationAndOwner(superOwner, annotation);
+            }
+        }
+        return null;
     }
 
-    if (isSet(flags, CHECK_INFERRED)) {
-      Project project = listOwner.getProject();
-      if (InferredAnnotationsManager.getInstance(project).findInferredAnnotation(listOwner, annotationFQN) != null) {
-        return true;
-      }
+    @Nullable
+    public static PsiAnnotation findAnnotation(@Nullable PsiModifierListOwner listOwner, String... annotationNames) {
+        return findAnnotation(listOwner, false, annotationNames);
     }
 
-    if (isSet(flags, CHECK_HIERARCHY)) {
-      if (listOwner instanceof PsiMethod) {
-        PsiMethod method = (PsiMethod)listOwner;
-        if (processed == null) {
-          processed = new HashSet<>();
+    @Nullable
+    public static PsiAnnotation findAnnotation(@Nullable PsiModifierListOwner listOwner,
+                                               boolean skipExternal,
+                                               String... annotationNames) {
+        if (annotationNames.length == 0) {
+            return null;
         }
-        if (!processed.add(method)) {
-          return false;
+        Set<String> set = annotationNames.length == 1 ? Collections.singleton(annotationNames[0]) : Set.of(annotationNames);
+        return findAnnotation(listOwner, set, skipExternal);
+    }
+
+    @Nullable
+    public static PsiAnnotation findAnnotation(@Nullable PsiModifierListOwner listOwner, Set<String> annotationNames) {
+        return findAnnotation(listOwner, (Collection<String>) annotationNames);
+    }
+
+    @Nullable
+    public static PsiAnnotation findAnnotation(@Nullable PsiModifierListOwner listOwner, Collection<String> annotationNames) {
+        return findAnnotation(listOwner, annotationNames, false);
+    }
+
+    @Nullable
+    public static PsiAnnotation findAnnotation(@Nullable PsiModifierListOwner listOwner,
+                                               Collection<String> annotationNames,
+                                               boolean skipExternal) {
+        if (listOwner == null) {
+            return null;
         }
-        for (PsiMethod superMethod : method.findSuperMethods()) {
-          if (isAnnotated(superMethod, annotationFQN, flags, processed)) {
-            return true;
-          }
+
+        PsiAnnotation annotation = findOwnAnnotation(listOwner, annotationNames);
+        if (annotation != null) {
+            return annotation;
         }
-      }
-      else if (listOwner instanceof PsiClass) {
-        PsiClass clazz = (PsiClass)listOwner;
-        if (processed == null) {
-          processed = new HashSet<>();
+        return skipExternal ? null : findNonCodeAnnotation(listOwner, annotationNames);
+    }
+
+    private static PsiAnnotation findOwnAnnotation(final PsiModifierListOwner listOwner, Collection<String> annotationNames) {
+        Map<Collection<String>, PsiAnnotation> map = LanguageCachedValueUtil.getCachedValue(listOwner, () ->
+        {
+            Map<Collection<String>, PsiAnnotation> value = ConcurrentFactoryMap.createMap(annotationNames1 ->
+            {
+                final PsiModifierList list =
+                    listOwner.getModifierList();
+                if (list == null) {
+                    return null;
+                }
+                for (PsiAnnotation annotation : list.getAnnotations()) {
+                    if (annotationNames1.contains(annotation.getQualifiedName())) {
+                        return annotation;
+                    }
+                }
+                return null;
+            });
+            return CachedValueProvider.Result.create(value, PsiModificationTracker.MODIFICATION_COUNT);
+        });
+        return map.get(annotationNames);
+    }
+
+    private static PsiAnnotation findNonCodeAnnotation(final PsiModifierListOwner listOwner, Collection<String> annotationNames) {
+        Map<Collection<String>, PsiAnnotation> map = LanguageCachedValueUtil.getCachedValue(listOwner, () ->
+        {
+            Map<Collection<String>, PsiAnnotation> value = ConcurrentFactoryMap.createMap(annotationNames1 ->
+            {
+                PsiUtilCore.ensureValid(listOwner);
+                final Project project = listOwner.getProject();
+                final ExternalAnnotationsManager annotationsManager =
+                    ExternalAnnotationsManager.getInstance(project);
+                for (String annotationName : annotationNames1) {
+                    final PsiAnnotation annotation =
+                        annotationsManager.findExternalAnnotation(
+                            listOwner,
+                            annotationName);
+                    if (annotation != null) {
+                        return annotation;
+                    }
+                }
+                final InferredAnnotationsManager
+                    inferredAnnotationsManager =
+                    InferredAnnotationsManager.getInstance(project);
+                for (String annotationName : annotationNames1) {
+                    final PsiAnnotation annotation =
+                        inferredAnnotationsManager.findInferredAnnotation(
+                            listOwner,
+                            annotationName);
+                    if (annotation != null) {
+                        return annotation;
+                    }
+                }
+                return null;
+
+            });
+            return CachedValueProvider.Result.create(value, PsiModificationTracker.MODIFICATION_COUNT);
+        });
+        return map.get(annotationNames);
+    }
+
+    public static PsiAnnotation[] findAnnotations(@Nullable PsiModifierListOwner modifierListOwner,
+                                                  Collection<String> annotationNames) {
+        if (modifierListOwner == null) {
+            return PsiAnnotation.EMPTY_ARRAY;
         }
-        if (!processed.add(clazz)) {
-          return false;
+        final PsiModifierList modifierList = modifierListOwner.getModifierList();
+        if (modifierList == null) {
+            return PsiAnnotation.EMPTY_ARRAY;
         }
-        for (PsiClass superClass : clazz.getSupers()) {
-          if (isAnnotated(superClass, annotationFQN, flags, processed)) {
-            return true;
-          }
-        }
-      }
-    }
-
-    return false;
-  }
-
-  public static boolean isAnnotatingApplicable(PsiElement elt) {
-    return isAnnotatingApplicable(elt, NullableNotNullManager.getInstance(elt.getProject()).getDefaultNullable());
-  }
-
-  public static boolean isAnnotatingApplicable(PsiElement elt, String annotationFQN) {
-    final Project project = elt.getProject();
-    return PsiUtil.isLanguageLevel5OrHigher(elt) && JavaPsiFacade.getInstance(project)
-                                                                 .findClass(annotationFQN, elt.getResolveScope()) != null;
-  }
-
-  /**
-   * Works similar to #isAnnotated(PsiModifierListOwner, Collection<String>) but supports FQN patters
-   * like "javax.ws.rs.*". Supports ending "*" only.
-   *
-   * @param owner       modifier list
-   * @param annotations annotations qualified names or patterns. Patterns can have '*' at the end
-   * @return {@code true} if annotated of at least one annotation from the annotations list
-   */
-  @Contract("null,_ -> false")
-  public static boolean checkAnnotatedUsingPatterns(@Nullable PsiModifierListOwner owner, Collection<String> annotations) {
-    final PsiModifierList modList;
-    if (owner == null || (modList = owner.getModifierList()) == null) {
-      return false;
-    }
-
-    List<String> fqns = null;
-    for (String fqn : annotations) {
-      boolean isPattern = fqn.endsWith("*");
-      if (!isPattern && isAnnotated(owner, fqn, 0)) {
-        return true;
-      }
-      else if (isPattern) {
-        if (fqns == null) {
-          fqns = new ArrayList<>();
-          final PsiAnnotation[] ownAnnotations = modList.getAnnotations();
-          for (PsiAnnotation anno : ownAnnotations) {
-            final String qName = anno.getQualifiedName();
-            if (qName != null) {
-              fqns.add(qName);
-            }
-          }
-          if (fqns.isEmpty()) {
-            return false;
-          }
+        final PsiAnnotation[] annotations = modifierList.getAnnotations();
+        ArrayList<PsiAnnotation> result = null;
+        for (final PsiAnnotation psiAnnotation : annotations) {
+            if (annotationNames.contains(psiAnnotation.getQualifiedName())) {
+                if (result == null) {
+                    result = new ArrayList<>();
+                }
+                result.add(psiAnnotation);
+            }
         }
-        fqn = fqn.substring(0, fqn.length() - 2);
-        for (String annoFQN : fqns) {
-          if (annoFQN.startsWith(fqn)) {
-            return true;
-          }
-        }
-      }
-    }
-    return false;
-  }
-
-  @Nullable
-  public static PsiMethod getAnnotationMethod(PsiNameValuePair pair) {
-    final PsiAnnotation annotation = PsiTreeUtil.getParentOfType(pair.getParent(), PsiAnnotation.class);
-    assert annotation != null;
-
-    final String fqn = annotation.getQualifiedName();
-    if (fqn == null) {
-      return null;
-    }
-
-    final PsiClass psiClass = JavaPsiFacade.getInstance(pair.getProject()).findClass(fqn, pair.getResolveScope());
-    if (psiClass != null && psiClass.isAnnotationType()) {
-      final String name = pair.getName();
-      return ArrayUtil.getFirstElement(psiClass.findMethodsByName(name != null ? name : "value", false));
-    }
-    return null;
-  }
-
-  public static PsiAnnotation[] getAllAnnotations(PsiModifierListOwner owner,
-                                                  boolean inHierarchy,
-                                                  @Nullable Set<PsiModifierListOwner> visited) {
-    return getAllAnnotations(owner, inHierarchy, visited, true);
-  }
-
-  public static PsiAnnotation[] getAllAnnotations(PsiModifierListOwner owner,
-                                                  boolean inHierarchy,
-                                                  @Nullable Set<PsiModifierListOwner> visited,
-                                                  boolean withInferred) {
-    final PsiModifierList list = owner.getModifierList();
-    PsiAnnotation[] annotations = PsiAnnotation.EMPTY_ARRAY;
-    if (list != null) {
-      annotations = list.getAnnotations();
-    }
-
-    final Project project = owner.getProject();
-    final PsiAnnotation[] externalAnnotations = ExternalAnnotationsManager.getInstance(project).findExternalAnnotations(owner);
-    if (externalAnnotations != null) {
-      annotations = ArrayUtil.mergeArrays(annotations, externalAnnotations, PsiAnnotation.ARRAY_FACTORY);
-    }
-    if (withInferred) {
-      final PsiAnnotation[] inferredAnnotations = InferredAnnotationsManager.getInstance(project).findInferredAnnotations(owner);
-      annotations = ArrayUtil.mergeArrays(annotations, inferredAnnotations, PsiAnnotation.ARRAY_FACTORY);
-    }
-
-    if (inHierarchy) {
-      if (owner instanceof PsiClass) {
-        for (PsiClass superClass : ((PsiClass)owner).getSupers()) {
-          if (visited == null) {
-            visited = new HashSet<>();
-          }
-          if (visited.add(superClass)) {
-            annotations = ArrayUtil.mergeArrays(annotations, getAllAnnotations(superClass, true, visited, withInferred));
-          }
-        }
-      }
-      else if (owner instanceof PsiMethod) {
-        PsiMethod method = (PsiMethod)owner;
-        PsiClass aClass = method.getContainingClass();
-        if (aClass != null) {
-          HierarchicalMethodSignature methodSignature = method.getHierarchicalMethodSignature();
-
-          final List<HierarchicalMethodSignature> superSignatures = methodSignature.getSuperSignatures();
-          PsiResolveHelper resolveHelper = PsiResolveHelper.getInstance(aClass.getProject());
-          for (final HierarchicalMethodSignature superSignature : superSignatures) {
+        return result == null ? PsiAnnotation.EMPTY_ARRAY : result.toArray(new PsiAnnotation[result.size()]);
+    }
+
+    public static <T extends PsiModifierListOwner> List<T> getSuperAnnotationOwners(T element) {
+        return LanguageCachedValueUtil.getCachedValue(element, () ->
+        {
+            Set<PsiModifierListOwner> result = new LinkedHashSet<>();
+            if (element instanceof PsiMethod) {
+                collectSuperMethods(result,
+                    ((PsiMethod) element).getHierarchicalMethodSignature(),
+                    element,
+                    JavaPsiFacade.getInstance(element.getProject()).getResolveHelper());
+            }
+            else if (element instanceof PsiClass) {
+                //noinspection unchecked
+                InheritanceUtil.processSupers((PsiClass) element, false, (Processor) Processors.cancelableCollectProcessor(result));
+            }
+            else if (element instanceof PsiParameter) {
+                collectSuperParameters(result, (PsiParameter) element);
+            }
+
+            //noinspection unchecked
+            List<T> list = new ArrayList<>((Collection<? extends T>) result);
+
+            return CachedValueProvider.Result.create(list, PsiModificationTracker.MODIFICATION_COUNT);
+        });
+    }
+
+
+    @Nullable
+    public static PsiAnnotation findAnnotationInHierarchy(final PsiModifierListOwner listOwner,
+                                                          Set<String> annotationNames, boolean skipExternal) {
+        PsiAnnotation directAnnotation = findAnnotation(listOwner, annotationNames, skipExternal);
+        if (directAnnotation != null) {
+            return directAnnotation;
+        }
+
+        for (PsiModifierListOwner superOwner : getSuperAnnotationOwners(listOwner)) {
+            PsiAnnotation annotation = findAnnotation(superOwner, annotationNames, skipExternal);
+            if (annotation != null) {
+                return annotation;
+            }
+        }
+        return null;
+    }
+
+    @Nullable
+    public static PsiAnnotation findAnnotationInHierarchy(final PsiModifierListOwner listOwner,
+                                                          Set<String> annotationNames) {
+        return findAnnotationInHierarchy(listOwner, annotationNames, false);
+    }
+
+    private static void collectSuperParameters(final Set<PsiModifierListOwner> result, PsiParameter parameter) {
+        PsiElement parent = parameter.getParent();
+        if (!(parent instanceof PsiParameterList)) {
+            return;
+        }
+        final int index = ((PsiParameterList) parent).getParameterIndex(parameter);
+        Consumer<PsiMethod> forEachSuperMethod = method ->
+        {
+            PsiParameter[] superParameters = method.getParameterList().getParameters();
+            if (index < superParameters.length) {
+                result.add(superParameters[index]);
+            }
+        };
+
+        PsiElement scope = parent.getParent();
+        if (scope instanceof PsiLambdaExpression) {
+            PsiMethod method = LambdaUtil.getFunctionalInterfaceMethod(((PsiLambdaExpression) scope).getFunctionalInterfaceType());
+            if (method != null) {
+                forEachSuperMethod.accept(method);
+                for (PsiMethod superMethod : getSuperAnnotationOwners(method)) {
+                    forEachSuperMethod.accept(superMethod);
+                }
+            }
+        }
+        else if (scope instanceof PsiMethod) {
+            for (PsiMethod superMethod : getSuperAnnotationOwners((PsiMethod) scope)) {
+                forEachSuperMethod.accept(superMethod);
+            }
+        }
+    }
+
+    private static void collectSuperMethods(Set<PsiModifierListOwner> result,
+                                            HierarchicalMethodSignature signature,
+                                            PsiElement place,
+                                            PsiResolveHelper resolveHelper) {
+        for (final HierarchicalMethodSignature superSignature : signature.getSuperSignatures()) {
             final PsiMethod superMethod = superSignature.getMethod();
-            if (visited == null) {
-              visited = new HashSet<>();
-            }
-            if (!visited.add(superMethod)) {
-              continue;
-            }
-            if (!resolveHelper.isAccessible(superMethod, owner, null)) {
-              continue;
-            }
-            annotations = ArrayUtil.mergeArrays(annotations, getAllAnnotations(superMethod, true, visited, withInferred));
-          }
-        }
-      }
-      else if (owner instanceof PsiParameter) {
-        PsiParameter parameter = (PsiParameter)owner;
-        PsiElement scope = parameter.getDeclarationScope();
-        if (scope instanceof PsiMethod) {
-          PsiMethod method = (PsiMethod)scope;
-          PsiClass aClass = method.getContainingClass();
-          PsiElement parent = parameter.getParent();
-          if (aClass != null && parent instanceof PsiParameterList) {
-            int index = ((PsiParameterList)parent).getParameterIndex(parameter);
-            HierarchicalMethodSignature methodSignature = method.getHierarchicalMethodSignature();
-
-            final List<HierarchicalMethodSignature> superSignatures = methodSignature.getSuperSignatures();
-            PsiResolveHelper resolveHelper = PsiResolveHelper.getInstance(aClass.getProject());
-            for (final HierarchicalMethodSignature superSignature : superSignatures) {
-              final PsiMethod superMethod = superSignature.getMethod();
-              if (visited == null) {
-                visited = new HashSet<>();
-              }
-              if (!visited.add(superMethod)) {
+            if (!resolveHelper.isAccessible(superMethod, place, null)) {
                 continue;
-              }
-              if (!resolveHelper.isAccessible(superMethod, owner, null)) {
+            }
+            if (!result.add(superMethod)) {
                 continue;
-              }
-              PsiParameter[] superParameters = superMethod.getParameterList().getParameters();
-              if (index < superParameters.length) {
-                annotations = ArrayUtil.mergeArrays(annotations, getAllAnnotations(superParameters[index], true, visited, withInferred));
-              }
             }
-          }
+            collectSuperMethods(result, superSignature, place, resolveHelper);
         }
-      }
     }
-    return annotations;
-  }
 
-  public static boolean isInsideAnnotation(PsiElement element) {
-    for (int level = 0; level < 4; level++) {
-      if (element instanceof PsiNameValuePair) {
-        return true;
-      }
-      element = element.getParent();
-      if (element == null) {
-        return false;
-      }
-    }
-    return false;
-  }
-
-  public static boolean isInferredAnnotation(PsiAnnotation annotation) {
-    return InferredAnnotationsManager.getInstance(annotation.getProject()).isInferredAnnotation(annotation);
-  }
-
-  public static boolean isExternalAnnotation(PsiAnnotation annotation) {
-    return ExternalAnnotationsManager.getInstance(annotation.getProject()).isExternalAnnotation(annotation);
-  }
-
-  @Nullable
-  public static String getStringAttributeValue(PsiAnnotation anno, @Nullable final String attributeName) {
-    PsiAnnotationMemberValue attrValue = anno.findAttributeValue(attributeName);
-    Object constValue = JavaPsiFacade.getInstance(anno.getProject()).getConstantEvaluationHelper().computeConstantExpression(attrValue);
-    return constValue instanceof String ? (String)constValue : null;
-  }
-
-  @Nullable
-  public static Boolean getBooleanAttributeValue(PsiAnnotation anno, @Nullable final String attributeName) {
-    PsiAnnotationMemberValue attrValue = anno.findAttributeValue(attributeName);
-    Object constValue = JavaPsiFacade.getInstance(anno.getProject()).getConstantEvaluationHelper().computeConstantExpression(attrValue);
-    return constValue instanceof Boolean ? (Boolean)constValue : null;
-  }
-
-  @Nullable
-  public static Long getLongAttributeValue(PsiAnnotation anno, @Nullable final String attributeName) {
-    PsiAnnotationMemberValue attrValue = anno.findAttributeValue(attributeName);
-    Object constValue = JavaPsiFacade.getInstance(anno.getProject()).getConstantEvaluationHelper().computeConstantExpression(attrValue);
-    return constValue instanceof Number ? ((Number)constValue).longValue() : null;
-  }
-
-  @Nullable
-  public static String getDeclaredStringAttributeValue(PsiAnnotation anno, @Nullable final String attributeName) {
-    PsiAnnotationMemberValue attrValue = anno.findDeclaredAttributeValue(attributeName);
-    Object constValue = JavaPsiFacade.getInstance(anno.getProject()).getConstantEvaluationHelper().computeConstantExpression(attrValue);
-    return constValue instanceof String ? (String)constValue : null;
-  }
-
-  @Nullable
-  public static <T extends Annotation> T findAnnotationInHierarchy(PsiModifierListOwner listOwner,
-                                                                   Class<T> annotationClass) {
-    PsiAnnotation annotation = findAnnotationInHierarchy(listOwner, Collections.singleton(annotationClass.getName()));
-    if (annotation == null) {
-      return null;
-    }
-    AnnotationInvocationHandler handler = new AnnotationInvocationHandler(annotationClass, annotation);
-    @SuppressWarnings("unchecked") T t =
-      (T)Proxy.newProxyInstance(annotationClass.getClassLoader(), new Class<?>[]{annotationClass}, handler);
-    return t;
-  }
-
-  /**
-   * @param attributeName "null means 'value'"
-   */
-  @Nullable
-  public static PsiNameValuePair findDeclaredAttribute(PsiAnnotation annotation, @Nullable() String attributeName) {
-    if (PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME.equals(attributeName)) {
-      attributeName = null;
-    }
-    for (PsiNameValuePair attribute : annotation.getParameterList().getAttributes()) {
-      final String name = attribute.getName();
-      if (Comparing.equal(name, attributeName) || attributeName == null && PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME.equals(name)) {
-        return attribute;
-      }
-    }
-    return null;
-  }
-
-  public static boolean equal(@Nullable PsiAnnotation a, @Nullable PsiAnnotation b) {
-    if (a == null) {
-      return b == null;
-    }
-    if (b == null) {
-      return false;
-    }
-    final String name = a.getQualifiedName();
-    if (name == null || !name.equals(b.getQualifiedName())) {
-      return false;
-    }
-    final Map<String, PsiAnnotationMemberValue> valueMap1 = new HashMap<>(2);
-    final Map<String, PsiAnnotationMemberValue> valueMap2 = new HashMap<>(2);
-    if (!fillValueMap(a.getParameterList(), valueMap1) || !fillValueMap(b.getParameterList(),
-                                                                        valueMap2) || valueMap1.size() != valueMap2.size()) {
-      return false;
-    }
-    for (Map.Entry<String, PsiAnnotationMemberValue> entry : valueMap1.entrySet()) {
-      if (!equal(entry.getValue(), valueMap2.get(entry.getKey()))) {
-        return false;
-      }
+    public static final int CHECK_HIERARCHY = 0x01;
+    public static final int CHECK_EXTERNAL = 0x02;
+    public static final int CHECK_INFERRED = 0x04;
+    public static final int CHECK_TYPE = 0x08;
+
+    @MagicConstant(flags = {
+        CHECK_HIERARCHY,
+        CHECK_EXTERNAL,
+        CHECK_INFERRED,
+        CHECK_TYPE
+    })
+    @Target({
+        ElementType.PARAMETER,
+        ElementType.METHOD
+    })
+    private @interface Flags {
+    }
+
+    public static boolean isAnnotated(PsiModifierListOwner listOwner, Collection<String> annotations, @Flags int flags) {
+        return annotations.stream().anyMatch(annotation -> isAnnotated(listOwner, annotation, flags, null));
     }
-    return true;
-  }
 
-  private static boolean fillValueMap(PsiAnnotationParameterList parameterList, Map<String, PsiAnnotationMemberValue> valueMap) {
-    final PsiNameValuePair[] attributes1 = parameterList.getAttributes();
-    for (PsiNameValuePair attribute : attributes1) {
-      final PsiReference reference = attribute.getReference();
-      if (reference == null) {
+    public static boolean isAnnotated(PsiModifierListOwner listOwner, String annotationFqn, @Flags int flags) {
+        return isAnnotated(listOwner, annotationFqn, flags, null);
+    }
+
+    private static boolean isAnnotated(PsiModifierListOwner listOwner, String annotationFQN, int flags, @Nullable Set<PsiMember> processed) {
+        if (!listOwner.isValid()) {
+            return false;
+        }
+
+        PsiModifierList modifierList = listOwner.getModifierList();
+        if (modifierList == null) {
+            return false;
+        }
+
+        PsiAnnotation annotation = modifierList.findAnnotation(annotationFQN);
+        if (annotation != null) {
+            return true;
+        }
+
+        if (isSet(flags, CHECK_TYPE)) {
+            PsiType type = null;
+            if (listOwner instanceof PsiMethod) {
+                type = ((PsiMethod) listOwner).getReturnType();
+            }
+            else if (listOwner instanceof PsiVariable) {
+                type = ((PsiVariable) listOwner).getType();
+            }
+            if (type != null && type.findAnnotation(annotationFQN) != null) {
+                return true;
+            }
+        }
+
+        if (isSet(flags, CHECK_EXTERNAL)) {
+            Project project = listOwner.getProject();
+            if (ExternalAnnotationsManager.getInstance(project).findExternalAnnotation(listOwner, annotationFQN) != null) {
+                return true;
+            }
+        }
+
+        if (isSet(flags, CHECK_INFERRED)) {
+            Project project = listOwner.getProject();
+            if (InferredAnnotationsManager.getInstance(project).findInferredAnnotation(listOwner, annotationFQN) != null) {
+                return true;
+            }
+        }
+
+        if (isSet(flags, CHECK_HIERARCHY)) {
+            if (listOwner instanceof PsiMethod) {
+                PsiMethod method = (PsiMethod) listOwner;
+                if (processed == null) {
+                    processed = new HashSet<>();
+                }
+                if (!processed.add(method)) {
+                    return false;
+                }
+                for (PsiMethod superMethod : method.findSuperMethods()) {
+                    if (isAnnotated(superMethod, annotationFQN, flags, processed)) {
+                        return true;
+                    }
+                }
+            }
+            else if (listOwner instanceof PsiClass) {
+                PsiClass clazz = (PsiClass) listOwner;
+                if (processed == null) {
+                    processed = new HashSet<>();
+                }
+                if (!processed.add(clazz)) {
+                    return false;
+                }
+                for (PsiClass superClass : clazz.getSupers()) {
+                    if (isAnnotated(superClass, annotationFQN, flags, processed)) {
+                        return true;
+                    }
+                }
+            }
+        }
+
         return false;
-      }
-      final PsiElement target = reference.resolve();
-      if (!(target instanceof PsiAnnotationMethod)) {
+    }
+
+    public static boolean isAnnotatingApplicable(PsiElement elt) {
+        return isAnnotatingApplicable(elt, NullableNotNullManager.getInstance(elt.getProject()).getDefaultNullable());
+    }
+
+    public static boolean isAnnotatingApplicable(PsiElement elt, String annotationFQN) {
+        final Project project = elt.getProject();
+        return PsiUtil.isLanguageLevel5OrHigher(elt) && JavaPsiFacade.getInstance(project)
+            .findClass(annotationFQN, elt.getResolveScope()) != null;
+    }
+
+    /**
+     * Works similar to #isAnnotated(PsiModifierListOwner, Collection<String>) but supports FQN patters
+     * like "javax.ws.rs.*". Supports ending "*" only.
+     *
+     * @param owner       modifier list
+     * @param annotations annotations qualified names or patterns. Patterns can have '*' at the end
+     * @return {@code true} if annotated of at least one annotation from the annotations list
+     */
+    @Contract("null,_ -> false")
+    public static boolean checkAnnotatedUsingPatterns(@Nullable PsiModifierListOwner owner, Collection<String> annotations) {
+        final PsiModifierList modList;
+        if (owner == null || (modList = owner.getModifierList()) == null) {
+            return false;
+        }
+
+        List<String> fqns = null;
+        for (String fqn : annotations) {
+            boolean isPattern = fqn.endsWith("*");
+            if (!isPattern && isAnnotated(owner, fqn, 0)) {
+                return true;
+            }
+            else if (isPattern) {
+                if (fqns == null) {
+                    fqns = new ArrayList<>();
+                    final PsiAnnotation[] ownAnnotations = modList.getAnnotations();
+                    for (PsiAnnotation anno : ownAnnotations) {
+                        final String qName = anno.getQualifiedName();
+                        if (qName != null) {
+                            fqns.add(qName);
+                        }
+                    }
+                    if (fqns.isEmpty()) {
+                        return false;
+                    }
+                }
+                fqn = fqn.substring(0, fqn.length() - 2);
+                for (String annoFQN : fqns) {
+                    if (annoFQN.startsWith(fqn)) {
+                        return true;
+                    }
+                }
+            }
+        }
         return false;
-      }
-      final PsiAnnotationMethod annotationMethod = (PsiAnnotationMethod)target;
-      final PsiAnnotationMemberValue defaultValue = annotationMethod.getDefaultValue();
-      final PsiAnnotationMemberValue value = attribute.getValue();
-      if (equal(value, defaultValue)) {
-        continue;
-      }
-      final String name1 = attribute.getName();
-      valueMap.put(name1 == null ? PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME : name1, value);
-    }
-    return true;
-  }
-
-  public static boolean equal(PsiAnnotationMemberValue value1, PsiAnnotationMemberValue value2) {
-    if (value1 instanceof PsiArrayInitializerMemberValue && value2 instanceof PsiArrayInitializerMemberValue) {
-      final PsiAnnotationMemberValue[] initializers1 = ((PsiArrayInitializerMemberValue)value1).getInitializers();
-      final PsiAnnotationMemberValue[] initializers2 = ((PsiArrayInitializerMemberValue)value2).getInitializers();
-      if (initializers1.length != initializers2.length) {
+    }
+
+    @Nullable
+    public static PsiMethod getAnnotationMethod(PsiNameValuePair pair) {
+        final PsiAnnotation annotation = PsiTreeUtil.getParentOfType(pair.getParent(), PsiAnnotation.class);
+        assert annotation != null;
+
+        final String fqn = annotation.getQualifiedName();
+        if (fqn == null) {
+            return null;
+        }
+
+        final PsiClass psiClass = JavaPsiFacade.getInstance(pair.getProject()).findClass(fqn, pair.getResolveScope());
+        if (psiClass != null && psiClass.isAnnotationType()) {
+            final String name = pair.getName();
+            return ArrayUtil.getFirstElement(psiClass.findMethodsByName(name != null ? name : "value", false));
+        }
+        return null;
+    }
+
+    public static PsiAnnotation[] getAllAnnotations(PsiModifierListOwner owner,
+                                                    boolean inHierarchy,
+                                                    @Nullable Set<PsiModifierListOwner> visited) {
+        return getAllAnnotations(owner, inHierarchy, visited, true);
+    }
+
+    public static PsiAnnotation[] getAllAnnotations(PsiModifierListOwner owner,
+                                                    boolean inHierarchy,
+                                                    @Nullable Set<PsiModifierListOwner> visited,
+                                                    boolean withInferred) {
+        final PsiModifierList list = owner.getModifierList();
+        PsiAnnotation[] annotations = PsiAnnotation.EMPTY_ARRAY;
+        if (list != null) {
+            annotations = list.getAnnotations();
+        }
+
+        final Project project = owner.getProject();
+        final PsiAnnotation[] externalAnnotations = ExternalAnnotationsManager.getInstance(project).findExternalAnnotations(owner);
+        if (externalAnnotations != null) {
+            annotations = ArrayUtil.mergeArrays(annotations, externalAnnotations, PsiAnnotation.ARRAY_FACTORY);
+        }
+        if (withInferred) {
+            final PsiAnnotation[] inferredAnnotations = InferredAnnotationsManager.getInstance(project).findInferredAnnotations(owner);
+            annotations = ArrayUtil.mergeArrays(annotations, inferredAnnotations, PsiAnnotation.ARRAY_FACTORY);
+        }
+
+        if (inHierarchy) {
+            if (owner instanceof PsiClass) {
+                for (PsiClass superClass : ((PsiClass) owner).getSupers()) {
+                    if (visited == null) {
+                        visited = new HashSet<>();
+                    }
+                    if (visited.add(superClass)) {
+                        annotations = ArrayUtil.mergeArrays(annotations, getAllAnnotations(superClass, true, visited, withInferred));
+                    }
+                }
+            }
+            else if (owner instanceof PsiMethod) {
+                PsiMethod method = (PsiMethod) owner;
+                PsiClass aClass = method.getContainingClass();
+                if (aClass != null) {
+                    HierarchicalMethodSignature methodSignature = method.getHierarchicalMethodSignature();
+
+                    final List<HierarchicalMethodSignature> superSignatures = methodSignature.getSuperSignatures();
+                    PsiResolveHelper resolveHelper = PsiResolveHelper.getInstance(aClass.getProject());
+                    for (final HierarchicalMethodSignature superSignature : superSignatures) {
+                        final PsiMethod superMethod = superSignature.getMethod();
+                        if (visited == null) {
+                            visited = new HashSet<>();
+                        }
+                        if (!visited.add(superMethod)) {
+                            continue;
+                        }
+                        if (!resolveHelper.isAccessible(superMethod, owner, null)) {
+                            continue;
+                        }
+                        annotations = ArrayUtil.mergeArrays(annotations, getAllAnnotations(superMethod, true, visited, withInferred));
+                    }
+                }
+            }
+            else if (owner instanceof PsiParameter) {
+                PsiParameter parameter = (PsiParameter) owner;
+                PsiElement scope = parameter.getDeclarationScope();
+                if (scope instanceof PsiMethod) {
+                    PsiMethod method = (PsiMethod) scope;
+                    PsiClass aClass = method.getContainingClass();
+                    PsiElement parent = parameter.getParent();
+                    if (aClass != null && parent instanceof PsiParameterList) {
+                        int index = ((PsiParameterList) parent).getParameterIndex(parameter);
+                        HierarchicalMethodSignature methodSignature = method.getHierarchicalMethodSignature();
+
+                        final List<HierarchicalMethodSignature> superSignatures = methodSignature.getSuperSignatures();
+                        PsiResolveHelper resolveHelper = PsiResolveHelper.getInstance(aClass.getProject());
+                        for (final HierarchicalMethodSignature superSignature : superSignatures) {
+                            final PsiMethod superMethod = superSignature.getMethod();
+                            if (visited == null) {
+                                visited = new HashSet<>();
+                            }
+                            if (!visited.add(superMethod)) {
+                                continue;
+                            }
+                            if (!resolveHelper.isAccessible(superMethod, owner, null)) {
+                                continue;
+                            }
+                            PsiParameter[] superParameters = superMethod.getParameterList().getParameters();
+                            if (index < superParameters.length) {
+                                annotations = ArrayUtil.mergeArrays(annotations, getAllAnnotations(superParameters[index], true, visited, withInferred));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return annotations;
+    }
+
+    public static boolean isInsideAnnotation(PsiElement element) {
+        for (int level = 0; level < 4; level++) {
+            if (element instanceof PsiNameValuePair) {
+                return true;
+            }
+            element = element.getParent();
+            if (element == null) {
+                return false;
+            }
+        }
         return false;
-      }
-      for (int i = 0; i < initializers1.length; i++) {
-        if (!equal(initializers1[i], initializers2[i])) {
-          return false;
-        }
-      }
-      return true;
-    }
-    if (value1 != null && value2 != null) {
-      final PsiConstantEvaluationHelper constantEvaluationHelper =
-        JavaPsiFacade.getInstance(value1.getProject()).getConstantEvaluationHelper();
-      final Object const1 = constantEvaluationHelper.computeConstantExpression(value1);
-      final Object const2 = constantEvaluationHelper.computeConstantExpression(value2);
-      return const1 != null && const1.equals(const2);
-    }
-    return false;
-  }
-
-  /**
-   * Ignores Override and SuppressWarnings annotations.
-   */
-  public static boolean equal(PsiAnnotation[] annotations1, PsiAnnotation[] annotations2) {
-    final Map<String, PsiAnnotation> map1 = buildAnnotationMap(annotations1);
-    final Map<String, PsiAnnotation> map2 = buildAnnotationMap(annotations2);
-    if (map1.size() != map2.size()) {
-      return false;
-    }
-    for (Map.Entry<String, PsiAnnotation> entry : map1.entrySet()) {
-      if (!equal(entry.getValue(), map2.get(entry.getKey()))) {
+    }
+
+    public static boolean isInferredAnnotation(PsiAnnotation annotation) {
+        return InferredAnnotationsManager.getInstance(annotation.getProject()).isInferredAnnotation(annotation);
+    }
+
+    public static boolean isExternalAnnotation(PsiAnnotation annotation) {
+        return ExternalAnnotationsManager.getInstance(annotation.getProject()).isExternalAnnotation(annotation);
+    }
+
+    @Nullable
+    public static String getStringAttributeValue(PsiAnnotation anno, @Nullable final String attributeName) {
+        PsiAnnotationMemberValue attrValue = anno.findAttributeValue(attributeName);
+        Object constValue = JavaPsiFacade.getInstance(anno.getProject()).getConstantEvaluationHelper().computeConstantExpression(attrValue);
+        return constValue instanceof String ? (String) constValue : null;
+    }
+
+    @Nullable
+    public static Boolean getBooleanAttributeValue(PsiAnnotation anno, @Nullable final String attributeName) {
+        PsiAnnotationMemberValue attrValue = anno.findAttributeValue(attributeName);
+        Object constValue = JavaPsiFacade.getInstance(anno.getProject()).getConstantEvaluationHelper().computeConstantExpression(attrValue);
+        return constValue instanceof Boolean ? (Boolean) constValue : null;
+    }
+
+    @Nullable
+    public static Long getLongAttributeValue(PsiAnnotation anno, @Nullable final String attributeName) {
+        PsiAnnotationMemberValue attrValue = anno.findAttributeValue(attributeName);
+        Object constValue = JavaPsiFacade.getInstance(anno.getProject()).getConstantEvaluationHelper().computeConstantExpression(attrValue);
+        return constValue instanceof Number ? ((Number) constValue).longValue() : null;
+    }
+
+    @Nullable
+    public static String getDeclaredStringAttributeValue(PsiAnnotation anno, @Nullable final String attributeName) {
+        PsiAnnotationMemberValue attrValue = anno.findDeclaredAttributeValue(attributeName);
+        Object constValue = JavaPsiFacade.getInstance(anno.getProject()).getConstantEvaluationHelper().computeConstantExpression(attrValue);
+        return constValue instanceof String ? (String) constValue : null;
+    }
+
+    @Nullable
+    public static <T extends Annotation> T findAnnotationInHierarchy(PsiModifierListOwner listOwner,
+                                                                     Class<T> annotationClass) {
+        PsiAnnotation annotation = findAnnotationInHierarchy(listOwner, Collections.singleton(annotationClass.getName()));
+        if (annotation == null) {
+            return null;
+        }
+        AnnotationInvocationHandler handler = new AnnotationInvocationHandler(annotationClass, annotation);
+        @SuppressWarnings("unchecked") T t =
+            (T) Proxy.newProxyInstance(annotationClass.getClassLoader(), new Class<?>[]{annotationClass}, handler);
+        return t;
+    }
+
+    /**
+     * @param attributeName "null means 'value'"
+     */
+    @Nullable
+    public static PsiNameValuePair findDeclaredAttribute(PsiAnnotation annotation, @Nullable() String attributeName) {
+        if (PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME.equals(attributeName)) {
+            attributeName = null;
+        }
+        for (PsiNameValuePair attribute : annotation.getParameterList().getAttributes()) {
+            final String name = attribute.getName();
+            if (Comparing.equal(name, attributeName) || attributeName == null && PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME.equals(name)) {
+                return attribute;
+            }
+        }
+        return null;
+    }
+
+    public static boolean equal(@Nullable PsiAnnotation a, @Nullable PsiAnnotation b) {
+        if (a == null) {
+            return b == null;
+        }
+        if (b == null) {
+            return false;
+        }
+        final String name = a.getQualifiedName();
+        if (name == null || !name.equals(b.getQualifiedName())) {
+            return false;
+        }
+        final Map<String, PsiAnnotationMemberValue> valueMap1 = new HashMap<>(2);
+        final Map<String, PsiAnnotationMemberValue> valueMap2 = new HashMap<>(2);
+        if (!fillValueMap(a.getParameterList(), valueMap1) || !fillValueMap(b.getParameterList(),
+            valueMap2) || valueMap1.size() != valueMap2.size()) {
+            return false;
+        }
+        for (Map.Entry<String, PsiAnnotationMemberValue> entry : valueMap1.entrySet()) {
+            if (!equal(entry.getValue(), valueMap2.get(entry.getKey()))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static boolean fillValueMap(PsiAnnotationParameterList parameterList, Map<String, PsiAnnotationMemberValue> valueMap) {
+        final PsiNameValuePair[] attributes1 = parameterList.getAttributes();
+        for (PsiNameValuePair attribute : attributes1) {
+            final PsiReference reference = attribute.getReference();
+            if (reference == null) {
+                return false;
+            }
+            final PsiElement target = reference.resolve();
+            if (!(target instanceof PsiAnnotationMethod)) {
+                return false;
+            }
+            final PsiAnnotationMethod annotationMethod = (PsiAnnotationMethod) target;
+            final PsiAnnotationMemberValue defaultValue = annotationMethod.getDefaultValue();
+            final PsiAnnotationMemberValue value = attribute.getValue();
+            if (equal(value, defaultValue)) {
+                continue;
+            }
+            final String name1 = attribute.getName();
+            valueMap.put(name1 == null ? PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME : name1, value);
+        }
+        return true;
+    }
+
+    public static boolean equal(PsiAnnotationMemberValue value1, PsiAnnotationMemberValue value2) {
+        if (value1 instanceof PsiArrayInitializerMemberValue && value2 instanceof PsiArrayInitializerMemberValue) {
+            final PsiAnnotationMemberValue[] initializers1 = ((PsiArrayInitializerMemberValue) value1).getInitializers();
+            final PsiAnnotationMemberValue[] initializers2 = ((PsiArrayInitializerMemberValue) value2).getInitializers();
+            if (initializers1.length != initializers2.length) {
+                return false;
+            }
+            for (int i = 0; i < initializers1.length; i++) {
+                if (!equal(initializers1[i], initializers2[i])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        if (value1 != null && value2 != null) {
+            final PsiConstantEvaluationHelper constantEvaluationHelper =
+                JavaPsiFacade.getInstance(value1.getProject()).getConstantEvaluationHelper();
+            final Object const1 = constantEvaluationHelper.computeConstantExpression(value1);
+            final Object const2 = constantEvaluationHelper.computeConstantExpression(value2);
+            return const1 != null && const1.equals(const2);
+        }
         return false;
-      }
-    }
-    return true;
-  }
-
-  private static Map<String, PsiAnnotation> buildAnnotationMap(PsiAnnotation[] annotations) {
-    final Map<String, PsiAnnotation> map = new HashMap<>();
-    for (PsiAnnotation annotation : annotations) {
-      map.put(annotation.getQualifiedName(), annotation);
-    }
-    map.remove(CommonClassNames.JAVA_LANG_OVERRIDE);
-    map.remove("java.lang.SuppressWarnings");
-    return map;
-  }
-
-  //<editor-fold desc="Deprecated stuff.">
-  /**
-   * @deprecated use {@link NullableNotNullManager} (to be removed in IDEA 2018)
-   */
-  private static final String[] SIMPLE_NAMES = {
-    "NotNull",
-    "Nullable",
-    "NonNls",
-    "PropertyKey",
-    "TestOnly",
-    "Language",
-    "Identifier",
-    "Pattern",
-    "PrintFormat",
-    "RegExp",
-    "Subst"
-  };
-
-  /**
-   * @deprecated wrong; do not use (to be removed in IDEA 2018)
-   */
-  public static boolean isJetbrainsAnnotation(String simpleName) {
-    return ArrayUtil.find(SIMPLE_NAMES, simpleName) != -1;
-  }
-
-  /**
-   * @deprecated use {@link #isAnnotated(PsiModifierListOwner, Collection, int)} (to be removed in IDEA 2019)
-   */
-  public static boolean isAnnotated(PsiModifierListOwner listOwner, Collection<String> annotations) {
-    return isAnnotated(listOwner, annotations, CHECK_TYPE);
-  }
-
-  /**
-   * @deprecated use {@link #isAnnotated(PsiModifierListOwner, Collection, int)} (to be removed in IDEA 2019)
-   */
-  public static boolean isAnnotated(PsiModifierListOwner listOwner,
-                                    Collection<String> annotations,
-                                    boolean checkHierarchy) {
-    return isAnnotated(listOwner, annotations, flags(checkHierarchy, true, true));
-  }
-
-  /**
-   * @deprecated use {@link #isAnnotated(PsiModifierListOwner, Collection, int)} (to be removed in IDEA 2019)
-   */
-  public static boolean isAnnotated(PsiModifierListOwner listOwner,
-                                    Collection<String> annotations,
-                                    boolean checkHierarchy,
-                                    boolean skipExternal) {
-    return isAnnotated(listOwner, annotations, flags(checkHierarchy, skipExternal, skipExternal));
-  }
-
-  /**
-   * @deprecated use {@link #isAnnotated(PsiModifierListOwner, String, int)} (to be removed in IDEA 2019)
-   */
-  public static boolean isAnnotated(PsiModifierListOwner listOwner, String annotationFQN, boolean checkHierarchy) {
-    return isAnnotated(listOwner, annotationFQN, flags(checkHierarchy, true, true));
-  }
-
-  /**
-   * @deprecated use {@link #isAnnotated(PsiModifierListOwner, String, int)} (to be removed in IDEA 2019)
-   */
-  public static boolean isAnnotated(PsiModifierListOwner listOwner,
-                                    String annotationFQN,
-                                    boolean checkHierarchy,
-                                    boolean skipExternal) {
-    return isAnnotated(listOwner, annotationFQN, flags(checkHierarchy, skipExternal, skipExternal));
-  }
-
-  /**
-   * @deprecated use {@link #isAnnotated(PsiModifierListOwner, String, int)} (to be removed in IDEA 2019)
-   */
-  public static boolean isAnnotated(PsiModifierListOwner listOwner,
-                                    String annotationFQN,
-                                    boolean checkHierarchy,
-                                    boolean skipExternal,
-                                    boolean skipInferred) {
-    return isAnnotated(listOwner, annotationFQN, flags(checkHierarchy, skipExternal, skipInferred));
-  }
-
-  private static
-  @Flags
-  int flags(boolean checkHierarchy, boolean skipExternal, boolean skipInferred) {
-    int flags = CHECK_TYPE;
-    if (checkHierarchy) {
-      flags |= CHECK_HIERARCHY;
-    }
-    if (!skipExternal) {
-      flags |= CHECK_EXTERNAL;
-    }
-    if (!skipInferred) {
-      flags |= CHECK_INFERRED;
-    }
-    return flags;
-  }
-  //</editor-fold>
-
-  public static List<PsiAnnotationMemberValue> arrayAttributeValues(@Nullable PsiAnnotationMemberValue attributeValue) {
-    if (attributeValue instanceof PsiArrayInitializerMemberValue) {
-      return Arrays.asList(((PsiArrayInitializerMemberValue)attributeValue).getInitializers());
-    }
-    return ContainerUtil.createMaybeSingletonList(attributeValue);
-  }
+    }
+
+    /**
+     * Ignores Override and SuppressWarnings annotations.
+     */
+    public static boolean equal(PsiAnnotation[] annotations1, PsiAnnotation[] annotations2) {
+        final Map<String, PsiAnnotation> map1 = buildAnnotationMap(annotations1);
+        final Map<String, PsiAnnotation> map2 = buildAnnotationMap(annotations2);
+        if (map1.size() != map2.size()) {
+            return false;
+        }
+        for (Map.Entry<String, PsiAnnotation> entry : map1.entrySet()) {
+            if (!equal(entry.getValue(), map2.get(entry.getKey()))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static Map<String, PsiAnnotation> buildAnnotationMap(PsiAnnotation[] annotations) {
+        final Map<String, PsiAnnotation> map = new HashMap<>();
+        for (PsiAnnotation annotation : annotations) {
+            map.put(annotation.getQualifiedName(), annotation);
+        }
+        map.remove(CommonClassNames.JAVA_LANG_OVERRIDE);
+        map.remove("java.lang.SuppressWarnings");
+        return map;
+    }
+
+    //<editor-fold desc="Deprecated stuff.">
+    /**
+     * @deprecated use {@link NullableNotNullManager} (to be removed in IDEA 2018)
+     */
+    private static final String[] SIMPLE_NAMES = {
+        "NotNull",
+        "Nullable",
+        "NonNls",
+        "PropertyKey",
+        "TestOnly",
+        "Language",
+        "Identifier",
+        "Pattern",
+        "PrintFormat",
+        "RegExp",
+        "Subst"
+    };
+
+    /**
+     * @deprecated wrong; do not use (to be removed in IDEA 2018)
+     */
+    public static boolean isJetbrainsAnnotation(String simpleName) {
+        return ArrayUtil.find(SIMPLE_NAMES, simpleName) != -1;
+    }
+
+    /**
+     * @deprecated use {@link #isAnnotated(PsiModifierListOwner, Collection, int)} (to be removed in IDEA 2019)
+     */
+    public static boolean isAnnotated(PsiModifierListOwner listOwner, Collection<String> annotations) {
+        return isAnnotated(listOwner, annotations, CHECK_TYPE);
+    }
+
+    /**
+     * @deprecated use {@link #isAnnotated(PsiModifierListOwner, Collection, int)} (to be removed in IDEA 2019)
+     */
+    public static boolean isAnnotated(PsiModifierListOwner listOwner,
+                                      Collection<String> annotations,
+                                      boolean checkHierarchy) {
+        return isAnnotated(listOwner, annotations, flags(checkHierarchy, true, true));
+    }
+
+    /**
+     * @deprecated use {@link #isAnnotated(PsiModifierListOwner, Collection, int)} (to be removed in IDEA 2019)
+     */
+    public static boolean isAnnotated(PsiModifierListOwner listOwner,
+                                      Collection<String> annotations,
+                                      boolean checkHierarchy,
+                                      boolean skipExternal) {
+        return isAnnotated(listOwner, annotations, flags(checkHierarchy, skipExternal, skipExternal));
+    }
+
+    /**
+     * @deprecated use {@link #isAnnotated(PsiModifierListOwner, String, int)} (to be removed in IDEA 2019)
+     */
+    public static boolean isAnnotated(PsiModifierListOwner listOwner, String annotationFQN, boolean checkHierarchy) {
+        return isAnnotated(listOwner, annotationFQN, flags(checkHierarchy, true, true));
+    }
+
+    /**
+     * @deprecated use {@link #isAnnotated(PsiModifierListOwner, String, int)} (to be removed in IDEA 2019)
+     */
+    public static boolean isAnnotated(PsiModifierListOwner listOwner,
+                                      String annotationFQN,
+                                      boolean checkHierarchy,
+                                      boolean skipExternal) {
+        return isAnnotated(listOwner, annotationFQN, flags(checkHierarchy, skipExternal, skipExternal));
+    }
+
+    /**
+     * @deprecated use {@link #isAnnotated(PsiModifierListOwner, String, int)} (to be removed in IDEA 2019)
+     */
+    public static boolean isAnnotated(PsiModifierListOwner listOwner,
+                                      String annotationFQN,
+                                      boolean checkHierarchy,
+                                      boolean skipExternal,
+                                      boolean skipInferred) {
+        return isAnnotated(listOwner, annotationFQN, flags(checkHierarchy, skipExternal, skipInferred));
+    }
+
+    private static
+    @Flags
+    int flags(boolean checkHierarchy, boolean skipExternal, boolean skipInferred) {
+        int flags = CHECK_TYPE;
+        if (checkHierarchy) {
+            flags |= CHECK_HIERARCHY;
+        }
+        if (!skipExternal) {
+            flags |= CHECK_EXTERNAL;
+        }
+        if (!skipInferred) {
+            flags |= CHECK_INFERRED;
+        }
+        return flags;
+    }
+    //</editor-fold>
+
+    public static List<PsiAnnotationMemberValue> arrayAttributeValues(@Nullable PsiAnnotationMemberValue attributeValue) {
+        if (attributeValue instanceof PsiArrayInitializerMemberValue) {
+            return Arrays.asList(((PsiArrayInitializerMemberValue) attributeValue).getInitializers());
+        }
+        return ContainerUtil.createMaybeSingletonList(attributeValue);
+    }
+
+    /**
+     * @param annotation annotation
+     * @return type that relates to that annotation
+     */
+    public static @Nullable PsiType getRelatedType(PsiAnnotation annotation) {
+        PsiAnnotationOwner owner = annotation.getOwner();
+        if (owner instanceof PsiType) {
+            return (PsiType) owner;
+        }
+        PsiType type = null;
+        if (owner instanceof PsiModifierList) {
+            PsiElement parent = ((PsiModifierList) owner).getParent();
+            PsiTypeElement typeElement = null;
+            if (parent instanceof PsiVariable) {
+                type = ((PsiVariable) parent).getType();
+                typeElement = ((PsiVariable) parent).getTypeElement();
+            }
+            if (parent instanceof PsiMethod) {
+                type = ((PsiMethod) parent).getReturnType();
+                typeElement = ((PsiMethod) parent).getReturnTypeElement();
+            }
+            if (type != null) {
+                PsiClass annoClass = annotation.resolveAnnotationType();
+                if (annoClass != null) {
+                    Set<PsiAnnotation.TargetType> targets = AnnotationTargetUtil.getAnnotationTargets(annoClass);
+                    if (targets != null && targets.contains(PsiAnnotation.TargetType.TYPE_USE) &&
+                        PsiUtil.isAvailable(JavaFeature.TYPE_ANNOTATIONS, parent)) {
+                        if (typeElement != null && targets.size() == 1) {
+                            // For ambiguous annotations, we assume that annotation on the outer type relates to the inner type
+                            // E.g. @Nullable Outer.Inner is equivalent to Outer.@Nullable Inner (if @Nullable is not type-use only)
+                            PsiJavaCodeReferenceElement ref = typeElement.getInnermostComponentReferenceElement();
+                            // See com.intellij.psi.impl.source.tree.java.PsiAnnotationImpl.getOwner
+                            while (ref != null && ref.isQualified()) {
+                                ref = ObjectUtil.tryCast(ref.getQualifier(), PsiJavaCodeReferenceElement.class);
+                            }
+                            if (ref != null) {
+                                return JavaPsiFacade.getElementFactory(annotation.getProject()).createType(ref);
+                            }
+                        }
+                        return type.getDeepComponentType();
+                    }
+                }
+                return type;
+            }
+        }
+        return null;
+    }
 }
\ No newline at end of file
diff --git a/java-language-api/src/main/java/com/intellij/java/language/codeInsight/Nullability.java b/java-language-api/src/main/java/com/intellij/java/language/codeInsight/Nullability.java
index 36dcb895a5..a29c6ec720 100644
--- a/java-language-api/src/main/java/com/intellij/java/language/codeInsight/Nullability.java
+++ b/java-language-api/src/main/java/com/intellij/java/language/codeInsight/Nullability.java
@@ -5,19 +5,18 @@
  * Represents a nullability (ability to hold, accept or return null) for variables, fields, method parameters, method return values,
  * type parameters and type arguments.
  */
-public enum Nullability
-{
-	/**
-	 * Value which cannot hold null; method which cannot return null; parameter which cannot accept null
-	 */
-	NOT_NULL,
-	/**
-	 * Value which holds null; method which can return null; parameter which accepts null
-	 */
-	NULLABLE,
-	/**
-	 * Nullability is not yet defined or "weak nullability" (e.g. method may return null, but often it can be determined
-	 * in some other way whether null is possible here, so null-check is not strictly necessary).
-	 */
-	UNKNOWN
+public enum Nullability {
+    /**
+     * Value which cannot hold null; method which cannot return null; parameter which cannot accept null
+     */
+    NOT_NULL,
+    /**
+     * Value which holds null; method which can return null; parameter which accepts null
+     */
+    NULLABLE,
+    /**
+     * Nullability is not yet defined or "weak nullability" (e.g. method may return null, but often it can be determined
+     * in some other way whether null is possible here, so null-check is not strictly necessary).
+     */
+    UNKNOWN
 }
diff --git a/java-language-api/src/main/java/com/intellij/java/language/codeInsight/NullableNotNullManager.java b/java-language-api/src/main/java/com/intellij/java/language/codeInsight/NullableNotNullManager.java
index 1f9a4d4669..d60917cd98 100644
--- a/java-language-api/src/main/java/com/intellij/java/language/codeInsight/NullableNotNullManager.java
+++ b/java-language-api/src/main/java/com/intellij/java/language/codeInsight/NullableNotNullManager.java
@@ -15,13 +15,11 @@
 import consulo.logging.Logger;
 import consulo.project.Project;
 import consulo.util.lang.ref.Ref;
-import org.jspecify.annotations.Nullable;
 import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jspecify.annotations.Nullable;
 
-import java.util.Collection;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
+import java.util.*;
 import java.util.stream.Collectors;
 
 import static com.intellij.java.language.codeInsight.AnnotationUtil.*;
@@ -48,6 +46,28 @@ protected interface NullabilityAnnotationDataHolder {
          */
         @Nullable
         Nullability getNullability(String annotation);
+
+        default boolean isWantedNullability(@NotNull Nullability nullability) {
+            return true;
+        }
+
+        /**
+         * @param map from annotation qualified name to nullability
+         * @return a data holder implementation based on the provided map
+         */
+        static @NotNull NullabilityAnnotationDataHolder fromMap(@NotNull Map<String, Nullability> map) {
+            return new NullabilityAnnotationDataHolder() {
+                @Override
+                public Set<String> qualifiedNames() {
+                    return map.keySet();
+                }
+
+                @Override
+                public @Nullable Nullability getNullability(String annotation) {
+                    return map.get(annotation);
+                }
+            };
+        }
     }
 
     public static NullableNotNullManager getInstance(Project project) {
@@ -76,6 +96,13 @@ public boolean hasNullability(PsiModifierListOwner owner) {
 
     public abstract void setNullables(String... annotations);
 
+    /**
+     * @param nullability wanted nullability
+     * @param context     PSI context
+     * @return the best suitable annotation to insert in a specified context
+     */
+    public abstract @NotNull String getDefaultAnnotation(@NotNull Nullability nullability, @NotNull PsiElement context);
+
     public abstract String getDefaultNullable();
 
     public abstract void setDefaultNullable(String defaultNullable);
@@ -168,7 +195,7 @@ private static PsiAnnotation copyAnnotation(PsiAnnotation annotation, PsiModifie
      */
     @Nullable
     public NullabilityAnnotationInfo findExplicitNullability(PsiModifierListOwner owner) {
-        NullabilityAnnotationInfo result = findPlainAnnotation(owner, false, true, getAllNullabilityAnnotationsWithNickNames());
+        NullabilityAnnotationInfo result = findPlainAnnotation(owner, true, getAllNullabilityAnnotationsWithNickNames());
         if (result != null) {
             return result;
         }
@@ -194,19 +221,18 @@ public NullabilityAnnotationInfo findEffectiveNullabilityInfo(PsiModifierListOwn
 
     @Nullable
     private NullabilityAnnotationInfo doFindEffectiveNullabilityAnnotation(PsiModifierListOwner owner) {
-        @Nullable NullabilityAnnotationInfo result = findPlainAnnotation(owner, true, false, getAllNullabilityAnnotationsWithNickNames());
+        NullabilityAnnotationDataHolder annotations = getAllNullabilityAnnotationsWithNickNames();
+        NullabilityAnnotationInfo result = findPlainOrContainerAnnotation(owner, annotations);
         if (result != null) {
             return result;
         }
 
-        boolean lambdaParameter = owner instanceof PsiParameter && owner.getParent() instanceof PsiParameterList &&
-            owner.getParent().getParent() instanceof PsiLambdaExpression;
-
-        if (!lambdaParameter) {
-            // For lambda parameter, inherited annotation overrides the default one
-            NullabilityAnnotationInfo defaultInfo = findNullityDefaultFiltered(owner);
-            if (defaultInfo != null) {
-                return defaultInfo;
+        if (owner instanceof PsiMethod) {
+            for (PsiModifierListOwner superOwner : getSuperAnnotationOwners(owner)) {
+                NullabilityAnnotationInfo superAnno = findPlainOrContainerAnnotation(superOwner, annotations);
+                if (superAnno != null) {
+                    return superAnno.withInheritedFrom(superOwner);
+                }
             }
         }
 
@@ -214,9 +240,9 @@ private NullabilityAnnotationInfo doFindEffectiveNullabilityAnnotation(PsiModifi
             List<PsiParameter> superParameters = getSuperAnnotationOwners((PsiParameter) owner);
             if (!superParameters.isEmpty()) {
                 for (PsiParameter parameter : superParameters) {
-                    NullabilityAnnotationInfo plain = findPlainAnnotation(parameter, false, false, getAllNullabilityAnnotationsWithNickNames());
+                    NullabilityAnnotationInfo plain = findPlainAnnotation(parameter, false, annotations);
                     // Plain not null annotation is not inherited
-                    if (plain != null) {
+                    if (plain != null && !plain.isContainer()) {
                         return null;
                     }
                     NullabilityAnnotationInfo defaultInfo = findContainerAnnotation(parameter);
@@ -228,8 +254,23 @@ private NullabilityAnnotationInfo doFindEffectiveNullabilityAnnotation(PsiModifi
             }
         }
 
-        if (lambdaParameter) {
-            return findNullityDefaultFiltered(owner);
+        return null;
+    }
+
+    private @Nullable NullabilityAnnotationInfo findPlainOrContainerAnnotation(@NotNull PsiModifierListOwner owner,
+                                                                               @NotNull NullabilityAnnotationDataHolder annotations) {
+        NullabilityAnnotationInfo result = findPlainAnnotation(owner, false, annotations);
+        if (result != null) {
+            return result;
+        }
+
+        boolean lambdaParameter = owner instanceof PsiParameter && owner.getParent() instanceof PsiParameterList &&
+            owner.getParent().getParent() instanceof PsiLambdaExpression;
+
+        if (!lambdaParameter) {
+            // For lambda parameter, default annotation is ignored
+            NullabilityAnnotationInfo defaultInfo = findNullityDefaultFiltered(owner);
+            if (defaultInfo != null) return defaultInfo;
         }
         return null;
     }
@@ -280,21 +321,21 @@ private NullabilityAnnotationInfo findNullabilityDefault(PsiElement place,
     }
 
     protected ContextNullabilityInfo findNullityDefaultOnPackage(PsiAnnotation.TargetType[] placeTargetTypes,
-                                                                          PsiFile file) {
+                                                                 PsiFile file) {
         return ContextNullabilityInfo.EMPTY;
     }
 
     protected ContextNullabilityInfo findNullityDefaultOnModule(PsiAnnotation.TargetType[] types,
-                                                                         PsiElement element) {
+                                                                PsiElement element) {
         return ContextNullabilityInfo.EMPTY;
     }
 
     /**
-     * @return an annotation (if any) with the given nullability semantics on the given declaration or its type. In case of conflicts,
+     * @return the annotation info (if any) with the given nullability semantics on the given declaration or its type. In case of conflicts,
      * type annotations are preferred.
      */
-    public @Nullable PsiAnnotation findExplicitNullabilityAnnotation(PsiModifierListOwner owner,
-                                                                     Collection<Nullability> nullabilities) {
+    public @Nullable NullabilityAnnotationInfo findNullabilityAnnotationInfo(@NotNull PsiModifierListOwner owner,
+                                                                             @NotNull Collection<Nullability> nullabilities) {
         NullabilityAnnotationDataHolder holder = getAllNullabilityAnnotationsWithNickNames();
         Set<String> filteredSet =
             holder.qualifiedNames().stream().filter(qName -> nullabilities.contains(holder.getNullability(qName))).collect(Collectors.toSet());
@@ -309,23 +350,20 @@ public Set<String> qualifiedNames() {
                 Nullability origNullability = holder.getNullability(annotation);
                 return nullabilities.contains(origNullability) ? origNullability : null;
             }
+
+            @Override
+            public boolean isWantedNullability(@NotNull Nullability nullability) {
+                return nullabilities.contains(nullability);
+            }
         };
-        NullabilityAnnotationInfo result = findPlainAnnotation(owner, false, false, filtered);
-        return result == null || !nullabilities.contains(result.getNullability()) ? null : result.getAnnotation();
+        NullabilityAnnotationInfo result = findPlainAnnotation(owner, false, filtered);
+        return result == null || !nullabilities.contains(result.getNullability()) ? null : result;
     }
 
-    private @Nullable NullabilityAnnotationInfo findPlainAnnotation(PsiModifierListOwner owner,
-                                                                    boolean checkBases,
-                                                                    boolean skipExternal,
-                                                                    NullabilityAnnotationDataHolder annotations) {
-        AnnotationAndOwner memberAnno;
-        if (checkBases && owner instanceof PsiMethod) {
-            memberAnno = findAnnotationAndOwnerInHierarchy(owner, annotations.qualifiedNames(), skipExternal);
-        }
-        else {
-            PsiAnnotation annotation = findAnnotation(owner, annotations.qualifiedNames(), skipExternal);
-            memberAnno = annotation == null ? null : new AnnotationAndOwner(owner, annotation);
-        }
+    private @Nullable NullabilityAnnotationInfo findPlainAnnotation(
+        @NotNull PsiModifierListOwner owner, boolean skipExternal, NullabilityAnnotationDataHolder annotations) {
+        PsiAnnotation annotation = findAnnotation(owner, annotations.qualifiedNames(), skipExternal);
+        AnnotationAndOwner memberAnno = annotation == null ? null : new AnnotationAndOwner(owner, annotation);
         PsiType type = PsiUtil.getTypeByPsiElement(owner);
         if (memberAnno != null && type instanceof PsiArrayType && !isInferredAnnotation(memberAnno.annotation) &&
             !isExternalAnnotation(memberAnno.annotation) && AnnotationTargetUtil.isTypeAnnotation(memberAnno.annotation)) {
@@ -358,10 +396,11 @@ public Set<String> qualifiedNames() {
             }
             return new NullabilityAnnotationInfo(memberAnno.annotation, nullability, memberAnno.owner == owner ? null : memberAnno.owner, false);
         }
-        if (type instanceof PsiPrimitiveType) {
+        if (type == null || type instanceof PsiPrimitiveType) {
             return null;
         }
-        return findAnnotationInTypeHierarchy(type, annotations);
+        NullabilityAnnotationInfo info = type.getNullability().toNullabilityAnnotationInfo();
+        return info != null && annotations.isWantedNullability(info.getNullability()) ? info : null;
     }
 
     /**
@@ -462,7 +501,13 @@ public NullabilityAnnotationInfo findDefaultTypeUseNullability(@Nullable PsiElem
     }
 
     protected abstract ContextNullabilityInfo getNullityDefault(PsiModifierListOwner container,
-                                                                         PsiAnnotation.TargetType[] placeTargetTypes);
+                                                                PsiAnnotation.TargetType[] placeTargetTypes);
+
+    /**
+     * @param owner annotation list to analyze (may belong to method, class, package statement, or module)
+     * @return list of conflicting annotations which denote different nullability; empty list if no conflicts were found
+     */
+    public abstract @NotNull List<@NotNull PsiAnnotation> getConflictingContainerAnnotations(@NotNull PsiModifierList owner);
 
     public abstract List<String> getNullables();
 
@@ -503,6 +548,14 @@ public static Nullability getNullability(PsiModifierListOwner owner) {
 
     public abstract void setInstrumentedNotNulls(List<String> names);
 
+    /**
+     * @param annotation annotation to check
+     * @return true if the annotation is a non-null annotation, which is used for instrumentation or code generation.
+     */
+    public boolean isNonNullUsedForInstrumentation(@NotNull PsiAnnotation annotation) {
+        return false;
+    }
+
     /**
      * Checks if given annotation specifies the nullability (either nullable or not-null)
      *
diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationOwner.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationOwner.java
index 6313b972be..9f3e8eaf1c 100644
--- a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationOwner.java
+++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationOwner.java
@@ -66,4 +66,11 @@ default boolean hasAnnotation(String qualifiedName) {
      * @return newly added annotation
      */
     PsiAnnotation addAnnotation(String qualifiedName);
+
+    /**
+     * @return true if there is at least one annotation attached to the element.
+     */
+    default boolean hasAnnotations() {
+        return getAnnotations().length > 0;
+    }
 }
diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/PsiImplUtil.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/PsiImplUtil.java
index 4afa3ec1b7..1c9e984605 100644
--- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/PsiImplUtil.java
+++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/PsiImplUtil.java
@@ -905,4 +905,25 @@ public static VirtualFile getModuleVirtualFile(PsiJavaModule module) {
             return module.getContainingFile().getVirtualFile();
         }
     }
+
+    @RequiredReadAction
+    public static boolean isTypeQualifierOfStaticMember(PsiJavaCodeReferenceElement ref) {
+        PsiElement parent = ref.getParent();
+        while (parent instanceof PsiJavaCodeReferenceElement) {
+            PsiJavaCodeReferenceElement referenceElement = (PsiJavaCodeReferenceElement) parent;
+            PsiElement qualified = referenceElement.resolve();
+            if (qualified instanceof PsiMember) {
+                if (((PsiMember) qualified).hasModifierProperty(PsiModifier.STATIC)) {
+                    return true;
+                }
+            }
+            if (qualified instanceof PsiClass) {
+                parent = parent.getParent();
+            }
+            else {
+                break;
+            }
+        }
+        return false;
+    }
 }
diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsModifierListImpl.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsModifierListImpl.java
index 2c1cce7fc0..5cf37d2927 100644
--- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsModifierListImpl.java
+++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsModifierListImpl.java
@@ -67,6 +67,11 @@ public PsiAnnotation[] getAnnotations() {
         return getStub().getChildrenByType(JavaStubElementTypes.ANNOTATION, PsiAnnotation.ARRAY_FACTORY);
     }
 
+    @Override
+    public boolean hasAnnotations() {
+        return getStub().findChildStubByType(JavaStubElementTypes.ANNOTATION) != null;
+    }
+
     @Override
     public PsiAnnotation[] getApplicableAnnotations() {
         return getAnnotations();
diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiModifierListImpl.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiModifierListImpl.java
index dac69723c3..830408395b 100644
--- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiModifierListImpl.java
+++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiModifierListImpl.java
@@ -313,6 +313,12 @@ public PsiAnnotation[] getAnnotations() {
         return ArrayUtil.mergeArrayAndCollection(own, ext, PsiAnnotation.ARRAY_FACTORY);
     }
 
+    @Override
+    public boolean hasAnnotations() {
+        return getStubOrPsiChild(JavaStubElementTypes.ANNOTATION) != null ||
+            !PsiAugmentProvider.collectAugments(this, PsiAnnotation.class, null).isEmpty();
+    }
+
     @Override
     @RequiredReadAction
     public PsiAnnotation[] getApplicableAnnotations() {
diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/NullableNotNullManagerImpl.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/NullableNotNullManagerImpl.java
index 97368124ba..b5f08bb725 100644
--- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/NullableNotNullManagerImpl.java
+++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/NullableNotNullManagerImpl.java
@@ -5,6 +5,7 @@
 import com.intellij.java.analysis.impl.codeInspection.dataFlow.HardcodedContracts;
 import com.intellij.java.indexing.impl.stubs.index.JavaAnnotationIndex;
 import com.intellij.java.language.annoPackages.AnnotationPackageSupport;
+import com.intellij.java.language.codeInsight.AnnotationUtil;
 import com.intellij.java.language.codeInsight.ContextNullabilityInfo;
 import com.intellij.java.language.codeInsight.Nullability;
 import com.intellij.java.language.codeInsight.NullableNotNullManager;
@@ -21,11 +22,16 @@
 import consulo.component.util.ModificationTracker;
 import consulo.component.util.SimpleModificationTracker;
 import consulo.java.language.impl.annoPackages.Jsr305Support;
+import consulo.language.impl.psi.DummyHolder;
 import consulo.language.psi.PsiElement;
+import consulo.language.psi.PsiFile;
 import consulo.language.psi.PsiModificationTracker;
 import consulo.language.psi.PsiPackage;
 import consulo.language.psi.scope.DelegatingGlobalSearchScope;
 import consulo.language.psi.scope.GlobalSearchScope;
+import consulo.language.util.ModuleUtilCore;
+import consulo.module.Module;
+import consulo.project.DumbService;
 import consulo.project.Project;
 import consulo.util.collection.ContainerUtil;
 import consulo.util.lang.StringUtil;
@@ -35,10 +41,12 @@
 import consulo.util.xml.serializer.WriteExternalException;
 import consulo.virtualFileSystem.VirtualFile;
 import consulo.virtualFileSystem.fileType.FileTypeRegistry;
-import org.jspecify.annotations.Nullable;
 import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
+import one.util.streamex.StreamEx;
 import org.jdom.Element;
+import org.jetbrains.annotations.NotNull;
+import org.jspecify.annotations.Nullable;
 
 import java.util.*;
 
@@ -100,6 +108,43 @@ public String getDefaultNullable() {
         return myDefaultNullable;
     }
 
+    @Override
+    public @NotNull String getDefaultAnnotation(@NotNull Nullability nullability, @NotNull PsiElement context) {
+        AnnotationPackageSupportCache cache = AnnotationPackageSupportCache.get(Application.get());
+
+        Collection<String> annotations = switch (nullability) {
+            case NOT_NULL -> myNotNulls;
+            case NULLABLE -> myNullables;
+            case UNKNOWN -> cache.myDefaultUnknowns.keySet();
+        };
+        PsiFile containingFile = context.getContainingFile();
+        if (containingFile instanceof DummyHolder) {
+            PsiElement element = containingFile.getContext();
+            if (element != null) {
+                containingFile = element.getContainingFile();
+            }
+        }
+        PsiFile file = containingFile.getOriginalFile();
+        Module module = ModuleUtilCore.findModuleForFile(file);
+        if (module == null) {
+            return getDefaultAnnotation(nullability);
+        }
+        for (String annotation : annotations) {
+            if (JavaLibraryUtil.hasLibraryClass(module, annotation)) {
+                return annotation;
+            }
+        }
+        return getDefaultAnnotation(nullability);
+    }
+
+    private @NotNull String getDefaultAnnotation(@NotNull Nullability nullability) {
+        return switch (nullability) {
+            case NOT_NULL -> getDefaultNotNull();
+            case NULLABLE -> getDefaultNullable();
+            case UNKNOWN -> AnnotationUtil.UNKNOWN_NULLABILITY;
+        };
+    }
+
     @Override
     public void setDefaultNullable(String defaultNullable) {
         LOG.assertTrue(getNullables().contains(defaultNullable));
@@ -182,6 +227,16 @@ public void setInstrumentedNotNulls(List<String> names) {
         myTracker.incModificationCount();
     }
 
+    @Override
+    public boolean isNonNullUsedForInstrumentation(@NotNull PsiAnnotation annotation) {
+        String qualifiedName = annotation.getQualifiedName();
+        if (qualifiedName == null) return false;
+        AnnotationPackageSupport support = AnnotationPackageSupport
+            .EP_NAME
+            .findFirstSafe(e -> e.getNullabilityAnnotations(Nullability.NOT_NULL).contains(qualifiedName));
+        return support != null && support.isNonNullUsedForInstrumentation();
+    }
+
     @Override
     protected boolean hasHardcodedContracts(PsiElement element) {
         return HardcodedContracts.hasHardcodedContracts(element);
@@ -214,7 +269,7 @@ public Element getState() {
 
     @Override
     protected ContextNullabilityInfo findNullityDefaultOnModule(PsiAnnotation.TargetType[] targetTypes,
-                                                                         PsiElement element) {
+                                                                PsiElement element) {
         PsiJavaModule module = JavaModuleGraphUtil.findDescriptorByElement(element);
         if (module != null) {
             return getNullityDefault(module, targetTypes);
@@ -259,23 +314,24 @@ private void normalizeDefaults() {
         myTracker.incModificationCount();
     }
 
-    private List<PsiClass> getAllNullabilityNickNames() {
+    private @NotNull Map<String, Nullability> getAllNullabilityNickNames() {
         if (!getNotNulls().contains(Jsr305Support.JAVAX_ANNOTATION_NONNULL)) {
-            return Collections.emptyList();
+            return Collections.emptyMap();
         }
         return CachedValuesManager.getManager(myProject).getCachedValue(myProject, () -> {
-            Set<PsiClass> result = new HashSet<>(getPossiblyUnresolvedJavaNicknameUsages());
             GlobalSearchScope scope = new DelegatingGlobalSearchScope(GlobalSearchScope.allScope(myProject)) {
                 @Override
-                public boolean contains(VirtualFile file) {
+                public boolean contains(@NotNull VirtualFile file) {
                     return super.contains(file) && !FileTypeRegistry.getInstance().isFileOfType(file, JavaFileType.INSTANCE);
                 }
             };
             PsiClass[] nickDeclarations = JavaPsiFacade.getInstance(myProject).findClasses(Jsr305Support.TYPE_QUALIFIER_NICKNAME, scope);
-            for (PsiClass tqNick : nickDeclarations) {
-                result.addAll(ContainerUtil.findAll(MetaAnnotationUtil.getChildren(tqNick, scope), Jsr305Support::isNullabilityNickName));
-            }
-            return CachedValueProvider.Result.create(new ArrayList<>(result), PsiModificationTracker.MODIFICATION_COUNT);
+            Map<String, Nullability> result = StreamEx.of(nickDeclarations)
+                .flatCollection(tqNick -> MetaAnnotationUtil.getChildren(tqNick, scope))
+                .prepend(getPossiblyUnresolvedJavaNicknameUsages())
+                .filter(Jsr305Support::isNullabilityNickName)
+                .toMap(PsiClass::getQualifiedName, Jsr305Support::getNickNamedNullability, (n1, n2) -> n1 == n2 ? n1 : Nullability.UNKNOWN);
+            return CachedValueProvider.Result.create(result, PsiModificationTracker.MODIFICATION_COUNT);
         });
     }
 
@@ -309,19 +365,36 @@ protected ContextNullabilityInfo getNullityDefault(PsiModifierListOwner containe
         return res;
     }
 
-    private ContextNullabilityInfo checkNullityDefault(PsiAnnotation annotation,
-                                                                PsiAnnotation.TargetType[] placeTargetTypes,
-                                                                boolean superPackage) {
-        ContextNullabilityInfo info = ContextNullabilityInfo.EMPTY;
-        for (AnnotationPackageSupport support : Application.get().getExtensionList(AnnotationPackageSupport.class)) {
-            info = info.orElse(support.getNullabilityByContainerAnnotation(annotation, placeTargetTypes, superPackage));
+    @Override
+    public @NotNull List<@NotNull PsiAnnotation> getConflictingContainerAnnotations(@NotNull PsiModifierList owner) {
+        if (!owner.hasAnnotations()) {
+            return List.of();
         }
-        return info;
+
+        return Application.get().getExtensionPoint(AnnotationPackageSupport.class).computeSafeIfAny(annotationPackageSupport -> {
+            List<@NotNull PsiAnnotation> annotations = annotationPackageSupport.getConflictingContainerAnnotations(owner);
+            if (!annotations.isEmpty()) {
+                return annotations;
+            }
+            return null;
+        }, List.of());
+    }
+
+    private ContextNullabilityInfo checkNullityDefault(PsiAnnotation annotation,
+                                                       PsiAnnotation.TargetType[] placeTargetTypes,
+                                                       boolean superPackage) {
+        return Application.get().getExtensionPoint(AnnotationPackageSupport.class).computeSafeIfAny(annotationPackageSupport -> {
+            ContextNullabilityInfo info = ContextNullabilityInfo.EMPTY;
+            for (AnnotationPackageSupport support : Application.get().getExtensionList(AnnotationPackageSupport.class)) {
+                info = info.orElse(support.getNullabilityByContainerAnnotation(annotation, placeTargetTypes, superPackage));
+            }
+
+            return info;
+        }, ContextNullabilityInfo.EMPTY);
     }
 
-    private List<String> filterNickNames(Nullability nullability) {
-        return ContainerUtil.mapNotNull(getAllNullabilityNickNames(),
-            c -> Jsr305Support.getNickNamedNullability(c) == nullability ? c.getQualifiedName() : null);
+    private @NotNull List<String> filterNickNames(@NotNull Nullability nullability) {
+        return StreamEx.ofKeys(getAllNullabilityNickNames(), nullability::equals).toList();
     }
 
     @Override
@@ -351,43 +424,37 @@ protected List<String> getNotNullsWithNickNames() {
 
     @Override
     protected NullabilityAnnotationDataHolder getAllNullabilityAnnotationsWithNickNames() {
-        AnnotationPackageSupportCache cache = AnnotationPackageSupportCache.get(myProject.getApplication());
-
+        if (DumbService.isDumb(myProject) || myProject.isDefault()) {
+            // Searching for nullability nicknames is not available in the dumb mode or for default project
+            return NullabilityAnnotationDataHolder.fromMap(getNullabilityMap());
+        }
         return CachedValuesManager.getManager(myProject).getCachedValue(myProject, () -> {
-            Map<String, Nullability> result = new HashMap<>();
-            for (String qName : cache.myDefaultAll) {
-                result.put(qName, null);
-            }
-            for (String qName : getNotNulls()) {
-                result.put(qName, Nullability.NOT_NULL);
-            }
-            for (String qName : getNullables()) {
-                result.put(qName, Nullability.NULLABLE);
-            }
-            for (String qName : cache.myDefaultUnknowns.keySet()) {
-                result.put(qName, Nullability.UNKNOWN);
-            }
-            for (PsiClass aClass : getAllNullabilityNickNames()) {
-                String qName = aClass.getQualifiedName();
-                if (qName != null) {
-                    result.putIfAbsent(qName, Jsr305Support.getNickNamedNullability(aClass));
-                }
-            }
-            NullabilityAnnotationDataHolder holder = new NullabilityAnnotationDataHolder() {
-                @Override
-                public Set<String> qualifiedNames() {
-                    return result.keySet();
-                }
-
-                @Override
-                public @Nullable Nullability getNullability(String annotation) {
-                    return result.get(annotation);
-                }
-            };
+            Map<String, Nullability> result = getNullabilityMap();
+            getAllNullabilityNickNames().forEach(result::putIfAbsent);
+            NullabilityAnnotationDataHolder holder = NullabilityAnnotationDataHolder.fromMap(result);
             return CachedValueProvider.Result.create(holder, PsiModificationTracker.MODIFICATION_COUNT);
         });
     }
 
+    private @NotNull Map<String, Nullability> getNullabilityMap() {
+        AnnotationPackageSupportCache cache = AnnotationPackageSupportCache.get(myProject.getApplication());
+
+        Map<String, Nullability> result = new HashMap<>();
+        for (String qName : cache.myDefaultAll) {
+            result.put(qName, null);
+        }
+        for (String qName : getNotNulls()) {
+            result.put(qName, Nullability.NOT_NULL);
+        }
+        for (String qName : getNullables()) {
+            result.put(qName, Nullability.NULLABLE);
+        }
+        for (String qName : cache.myDefaultUnknowns.keySet()) {
+            result.put(qName, Nullability.UNKNOWN);
+        }
+        return result;
+    }
+
     @Override
     public long getModificationCount() {
         return myTracker.getModificationCount();