Refactoring descendants of PsiAnnotationOwner.

Author: unv-unv

java-language-api/src/main/java/com/intellij/java/language/psi/PsiModifierList.java

@@ -15,10 +15,10 @@
  */
 package com.intellij.java.language.psi;
 
+import consulo.annotation.access.RequiredReadAction;
 import consulo.language.psi.PsiElement;
 import consulo.language.util.IncorrectOperationException;
 import jakarta.annotation.Nonnull;
-import org.jetbrains.annotations.NonNls;
 
 /**
  * Represents the list of modifiers and annotations on a Java element (class, method,
@@ -35,7 +35,8 @@ public interface PsiModifierList extends PsiElement, PsiAnnotationOwner {
      * @return true if the list has the modifier, false otherwise
      * @see #hasExplicitModifier(String)
      */
-    boolean hasModifierProperty(@PsiModifier.ModifierConstant @Nonnull @NonNls String name);
+    @RequiredReadAction
+    boolean hasModifierProperty(@PsiModifier.ModifierConstant @Nonnull String name);
 
     /**
      * Checks if the modifier list has the specified modifier set by an explicit keyword.
@@ -44,7 +45,7 @@ public interface PsiModifierList extends PsiElement, PsiAnnotationOwner {
      * @return true if the list has the modifier, false otherwise
      * @see #hasModifierProperty(String)
      */
-    boolean hasExplicitModifier(@PsiModifier.ModifierConstant @Nonnull @NonNls String name);
+    boolean hasExplicitModifier(@PsiModifier.ModifierConstant @Nonnull String name);
 
     /**
      * Adds or removes the specified modifier to the modifier list.
@@ -53,7 +54,7 @@ public interface PsiModifierList extends PsiElement, PsiAnnotationOwner {
      * @param value true if the modifier should be added, false if it should be removed.
      * @throws IncorrectOperationException if the modification fails for some reason.
      */
-    void setModifierProperty(@PsiModifier.ModifierConstant @Nonnull @NonNls String name, boolean value) throws IncorrectOperationException;
+    void setModifierProperty(@PsiModifier.ModifierConstant @Nonnull String name, boolean value) throws IncorrectOperationException;
 
     /**
      * Checks if it is possible to add or remove the specified modifier to the modifier list,
@@ -64,6 +65,6 @@ public interface PsiModifierList extends PsiElement, PsiAnnotationOwner {
      * @param value true if the modifier should be added, false if it should be removed.
      * @throws IncorrectOperationException if the modification fails for some reason.
      */
-    void checkSetModifierProperty(@PsiModifier.ModifierConstant @Nonnull @NonNls String name, boolean value)
+    void checkSetModifierProperty(@PsiModifier.ModifierConstant @Nonnull String name, boolean value)
         throws IncorrectOperationException;
 }

java-language-api/src/main/java/com/intellij/java/language/psi/PsiType.java

@@ -62,7 +62,7 @@ public static PsiType[] createArray(int count) {
     /**
      * Constructs a PsiType with given annotations
      */
-    protected PsiType(@Nonnull final PsiAnnotation[] annotations) {
+    protected PsiType(@Nonnull PsiAnnotation[] annotations) {
         this(TypeAnnotationProvider.Static.create(annotations));
     }
 
@@ -145,7 +145,7 @@ public String getInternalCanonicalText() {
      * Checks if the type is currently valid.
      *
      * @return true if the type is valid, false otherwise.
-     * @see PsiElement#isValid()
+     * @see consulo.language.psi.PsiElement#isValid()
      */
     public abstract boolean isValid();
 
@@ -175,7 +175,7 @@ public boolean isConvertibleFrom(@Nonnull PsiType type) {
      * Returns the class type for qualified class name.
      *
      * @param qName        qualified class name.
-     * @param project
+     * @param project      current project.
      * @param resolveScope the scope in which the class is searched.
      * @return the class instance.
      */
@@ -272,9 +272,9 @@ public static PsiClassType getJavaLangRuntimeException(@Nonnull PsiManager manag
     public final int getArrayDimensions() {
         PsiType type = this;
         int dims = 0;
-        while (type instanceof PsiArrayType) {
+        while (type instanceof PsiArrayType arrayType) {
             dims++;
-            type = ((PsiArrayType)type).getComponentType();
+            type = arrayType.getComponentType();
         }
         return dims;
     }
@@ -288,8 +288,8 @@ public final int getArrayDimensions() {
     @Nonnull
     public final PsiType getDeepComponentType() {
         PsiType type = this;
-        while (type instanceof PsiArrayType) {
-            type = ((PsiArrayType)type).getComponentType();
+        while (type instanceof PsiArrayType arrayType) {
+            type = arrayType.getComponentType();
         }
         return type;
     }

java-language-api/src/main/java/com/intellij/java/language/psi/PsiTypeParameter.java

@@ -18,9 +18,8 @@
 import com.intellij.java.language.jvm.JvmTypeParameter;
 import com.intellij.java.language.jvm.types.JvmReferenceType;
 import consulo.util.collection.ArrayFactory;
-import jakarta.annotation.Nullable;
-import org.jetbrains.annotations.NonNls;
 import jakarta.annotation.Nonnull;
+import jakarta.annotation.Nullable;
 
 /**
  * Represents the type parameter of a generic class, interface, method or constructor.
@@ -40,8 +39,8 @@ public interface PsiTypeParameter extends PsiClass, PsiAnnotationOwner, JvmTypeP
      *
      * @return the extends list. For this particular kind of classes it never returns null.
      */
-    @Override
     @Nonnull
+    @Override
     PsiReferenceList getExtendsList();
 
     /**
@@ -67,7 +66,7 @@ default PsiAnnotation[] getAnnotations() {
     }
 
     @Override
-    default boolean hasAnnotation(@Nonnull @NonNls String fqn) {
+    default boolean hasAnnotation(@Nonnull String fqn) {
         return PsiClass.super.hasAnnotation(fqn);
     }
 

java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/PsiImplUtil.java

@@ -214,6 +214,7 @@ public static int getTypeParameterIndex(@Nonnull PsiTypeParameter typeParameter,
     }
 
     @Nonnull
+    @RequiredReadAction
     public static Object[] getReferenceVariantsByFilter(@Nonnull PsiJavaCodeReferenceElement reference, @Nonnull ElementFilter filter) {
         FilterScopeProcessor processor = new FilterScopeProcessor(filter);
         PsiScopesUtil.resolveAndWalk(processor, reference, null, true);
@@ -383,6 +384,7 @@ public static PsiAnnotation findAnnotation(@Nullable PsiAnnotationOwner annotati
      * @deprecated use {@link AnnotationTargetUtil#findAnnotationTarget(PsiAnnotation, TargetType...)} (to be removed ion IDEA 17)
      */
     @SuppressWarnings("unused")
+    @RequiredReadAction
     public static TargetType findApplicableTarget(@Nonnull PsiAnnotation annotation, @Nonnull TargetType... types) {
         return AnnotationTargetUtil.findAnnotationTarget(annotation, types);
     }
@@ -391,6 +393,7 @@ public static TargetType findApplicableTarget(@Nonnull PsiAnnotation annotation,
      * @deprecated use {@link AnnotationTargetUtil#findAnnotationTarget(PsiClass, TargetType...)} (to be removed ion IDEA 17)
      */
     @SuppressWarnings("unused")
+    @RequiredReadAction
     public static TargetType findApplicableTarget(@Nonnull PsiClass annotationType, @Nonnull TargetType... types) {
         return AnnotationTargetUtil.findAnnotationTarget(annotationType, types);
     }
@@ -399,6 +402,7 @@ public static TargetType findApplicableTarget(@Nonnull PsiClass annotationType,
      * @deprecated use {@link AnnotationTargetUtil#getAnnotationTargets(PsiClass)} (to be removed ion IDEA 17)
      */
     @SuppressWarnings("unused")
+    @RequiredReadAction
     public static Set<TargetType> getAnnotationTargets(@Nonnull PsiClass annotationType) {
         return AnnotationTargetUtil.getAnnotationTargets(annotationType);
     }
@@ -744,10 +748,12 @@ public static PsiModifierList findNeighbourModifierList(@Nonnull PsiJavaCodeRefe
         return null;
     }
 
+    @RequiredReadAction
     public static boolean isTypeAnnotation(@Nullable PsiElement element) {
         return element instanceof PsiAnnotation annotation && AnnotationTargetUtil.isTypeAnnotation(annotation);
     }
 
+    @RequiredReadAction
     public static void collectTypeUseAnnotations(@Nonnull PsiModifierList modifierList, @Nonnull List<PsiAnnotation> annotations) {
         for (PsiAnnotation annotation : modifierList.getAnnotations()) {
             if (AnnotationTargetUtil.isTypeAnnotation(annotation)) {
@@ -760,6 +766,7 @@ public static void collectTypeUseAnnotations(@Nonnull PsiModifierList modifierLi
      * @deprecated use {@link #collectTypeUseAnnotations(PsiModifierList, List)} (to be removed in IDEA 16)
      */
     @SuppressWarnings("unused")
+    @RequiredReadAction
     public static List<PsiAnnotation> getTypeUseAnnotations(@Nonnull PsiModifierList modifierList) {
         SmartList<PsiAnnotation> result = null;
 
@@ -789,7 +796,7 @@ public static void markTypeAnnotations(@Nonnull PsiTypeElement typeElement) {
         }
     }
 
-    @RequiredReadAction
+    @RequiredWriteAction
     public static void deleteTypeAnnotations(@Nonnull PsiTypeElement typeElement) {
         PsiElement left = PsiTreeUtil.skipSiblingsBackward(typeElement, PsiComment.class, PsiWhiteSpace.class, PsiTypeParameterList.class);
         if (left instanceof PsiModifierList modifierList) {
@@ -809,6 +816,7 @@ public static boolean isLeafElementOfType(PsiElement element, TokenSet tokenSet)
         return element instanceof LeafElement leafElement && tokenSet.contains(leafElement.getElementType());
     }
 
+    @RequiredReadAction
     public static PsiType buildTypeFromTypeString(@Nonnull String typeName, @Nonnull PsiElement context, @Nonnull PsiFile psiFile) {
         PsiType resultType;
         PsiManager psiManager = psiFile.getManager();

java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsModifierListImpl.java

@@ -21,6 +21,7 @@
 import com.intellij.java.language.impl.psi.impl.java.stubs.PsiModifierListStub;
 import com.intellij.java.language.impl.psi.impl.source.tree.JavaElementType;
 import com.intellij.java.language.psi.*;
+import consulo.annotation.access.RequiredReadAction;
 import consulo.language.impl.ast.TreeElement;
 import consulo.language.impl.psi.SourceTreeToPsiMap;
 import consulo.language.psi.PsiElement;
@@ -34,18 +35,21 @@ public ClsModifierListImpl(PsiModifierListStub stub) {
         super(stub);
     }
 
-    @Override
     @Nonnull
+    @Override
+    @RequiredReadAction
     public PsiElement[] getChildren() {
         return getAnnotations();
     }
 
     @Override
+    @RequiredReadAction
     public boolean hasModifierProperty(@Nonnull String name) {
         return ModifierFlags.hasModifierProperty(name, getStub().getModifiersMask());
     }
 
     @Override
+    @RequiredReadAction
     public boolean hasExplicitModifier(@Nonnull String name) {
         return hasModifierProperty(name);
     }
@@ -84,6 +88,7 @@ public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) {
     }
 
     @Override
+    @RequiredReadAction
     public void appendMirrorText(int indentLevel, @Nonnull StringBuilder buffer) {
         PsiElement parent = getParent();
         PsiAnnotation[] annotations = getAnnotations();
@@ -99,11 +104,11 @@ public void appendMirrorText(int indentLevel, @Nonnull StringBuilder buffer) {
         boolean isClass = parent instanceof PsiClass;
         boolean isInterface = isClass && ((PsiClass)parent).isInterface();
         boolean isEnum = isClass && ((PsiClass)parent).isEnum();
-        boolean isInterfaceClass = isClass && parent.getParent() instanceof PsiClass && ((PsiClass)parent.getParent()).isInterface();
+        boolean isInterfaceClass = isClass && parent.getParent() instanceof PsiClass outerClass && outerClass.isInterface();
         boolean isMethod = parent instanceof PsiMethod;
-        boolean isInterfaceMethod = isMethod && parent.getParent() instanceof PsiClass && ((PsiClass)parent.getParent()).isInterface();
+        boolean isInterfaceMethod = isMethod && parent.getParent() instanceof PsiClass psiClass && psiClass.isInterface();
         boolean isField = parent instanceof PsiField;
-        boolean isInterfaceField = isField && parent.getParent() instanceof PsiClass && ((PsiClass)parent.getParent()).isInterface();
+        boolean isInterfaceField = isField && parent.getParent() instanceof PsiClass psiClass && psiClass.isInterface();
         boolean isEnumConstant = parent instanceof PsiEnumConstant;
 
         if (hasModifierProperty(PsiModifier.PUBLIC) && !isInterfaceMethod && !isInterfaceField && !isInterfaceClass && !isEnumConstant) {
@@ -158,8 +163,8 @@ public void setMirror(@Nonnull TreeElement element) throws InvalidMirrorExceptio
 
     @Override
     public void accept(@Nonnull PsiElementVisitor visitor) {
-        if (visitor instanceof JavaElementVisitor) {
-            ((JavaElementVisitor)visitor).visitModifierList(this);
+        if (visitor instanceof JavaElementVisitor elemVisitor) {
+            elemVisitor.visitModifierList(this);
         }
         else {
             visitor.visitElement(this);