Refactoring of BaseRefactoringProcessor descendants (part 2). (#190)

Author: unv-unv

java-language-api/src/main/java/com/intellij/java/language/util/VisibilityUtil.java

@@ -39,7 +39,6 @@
 import jakarta.annotation.Nonnull;
 
 public class VisibilityUtil {
-    @NonNls
     public static final String ESCALATE_VISIBILITY = "EscalateVisible";
     private static final String[] visibilityModifiers = {
         PsiModifier.PRIVATE,
@@ -61,7 +60,7 @@ public static String getHighestVisibility(@PsiModifier.ModifierConstant String v
     }
 
     public static void escalateVisibility(PsiMember modifierListOwner, PsiElement place) throws IncorrectOperationException {
-        final String visibilityModifier = getVisibilityModifier(modifierListOwner.getModifierList());
+        String visibilityModifier = getVisibilityModifier(modifierListOwner.getModifierList());
         int index;
         for (index = 0; index < visibilityModifiers.length; index++) {
             String modifier = visibilityModifiers[index];
@@ -76,14 +75,14 @@ public static void escalateVisibility(PsiMember modifierListOwner, PsiElement pl
     }
 
     public static void escalateVisibility(PsiModifierList modifierList, PsiElement place) throws IncorrectOperationException {
-        final PsiElement parent = modifierList.getParent();
+        PsiElement parent = modifierList.getParent();
         if (parent instanceof PsiMember) {
             escalateVisibility((PsiMember)parent, place);
         }
     }
 
     @PsiModifier.ModifierConstant
-    public static String getPossibleVisibility(final PsiMember psiMethod, final PsiElement place) {
+    public static String getPossibleVisibility(PsiMember psiMethod, PsiElement place) {
         Project project = psiMethod.getProject();
         if (PsiUtil.isAccessible(project, psiMethod, place, null)) {
             return getVisibilityModifier(psiMethod.getModifierList());
@@ -111,7 +110,6 @@ public static String getVisibilityModifier(PsiModifierList list) {
     }
 
     @Nonnull
-    @NonNls
     public static String getVisibilityString(@PsiModifier.ModifierConstant String visibilityModifier) {
         if (PsiModifier.PACKAGE_LOCAL.equals(visibilityModifier)) {
             return "";
@@ -122,13 +120,13 @@ public static String getVisibilityString(@PsiModifier.ModifierConstant String vi
     @Nls
     @Nonnull
     public static String getVisibilityStringToDisplay(@Nonnull PsiMember member) {
-        if (member.hasModifierProperty(PsiModifier.PUBLIC)) {
+        if (member.isPublic()) {
             return toPresentableText(PsiModifier.PUBLIC);
         }
-        if (member.hasModifierProperty(PsiModifier.PROTECTED)) {
+        if (member.isProtected()) {
             return toPresentableText(PsiModifier.PROTECTED);
         }
-        if (member.hasModifierProperty(PsiModifier.PRIVATE)) {
+        if (member.isPrivate()) {
             return toPresentableText(PsiModifier.PRIVATE);
         }
         return toPresentableText(PsiModifier.PACKAGE_LOCAL);

plugin/src/main/java/com/intellij/java/impl/internal/diGraph/analyzer/GlobalAnalyzer.java

@@ -19,66 +19,66 @@
 
 import java.util.Iterator;
 import java.util.LinkedList;
+import java.util.List;
 
 /**
- * Created by IntelliJ IDEA.
- * User: db
- * Date: 21.06.2003
- * Time: 20:23:16
- * To change this template use Options | File Templates.
+ * @author db
+ * @since 2003-06-21
  */
 public class GlobalAnalyzer {
-    private static boolean stepOneEnd(MarkedNode currNode, LinkedList worklist, OneEndFunctor functor) {
+    @SuppressWarnings("unchecked")
+    private static <T extends MarkedNode> boolean stepOneEnd(MarkedNode currNode, List<T> worklist, OneEndFunctor functor) {
         boolean result = false;
 
-        for (Iterator i = currNode.outIterator(); i.hasNext(); ) {
-            MarkedEdge currEdge = (MarkedEdge)i.next();
+        for (Iterator<MarkedEdge> i = currNode.outIterator(); i.hasNext(); ) {
+            MarkedEdge currEdge = i.next();
             MarkedNode nextNode = (MarkedNode)currEdge.end();
             Mark theMark = functor.compute(currNode.getMark(), currEdge.getMark(), nextNode.getMark());
             if (!theMark.coincidesWith(nextNode.getMark())) {
                 result = true;
                 nextNode.setMark(theMark);
-                worklist.addFirst(nextNode);
+                worklist.addFirst((T)nextNode);
             }
         }
 
         return result;
     }
 
-    private static boolean stepTwoEnds(final MarkedNode currNode, final LinkedList worklist, final TwoEndsFunctor functor) {
+    @SuppressWarnings("unchecked")
+    private static <T extends MarkedNode> boolean stepTwoEnds(MarkedNode currNode, List<T> worklist, TwoEndsFunctor functor) {
         boolean result = false;
 
         for (Iterator i = currNode.outIterator(); i.hasNext(); ) {
-            final MarkedEdge currEdge = (MarkedEdge)i.next();
-            final MarkedNode nextNode = (MarkedNode)currEdge.end();
-            final Pair<Mark, Mark> markPair = functor.compute(currNode.getMark(), currEdge.getMark(), nextNode.getMark());
+            MarkedEdge currEdge = (MarkedEdge)i.next();
+            MarkedNode nextNode = (MarkedNode)currEdge.end();
+            Pair<Mark, Mark> markPair = functor.compute(currNode.getMark(), currEdge.getMark(), nextNode.getMark());
 
-            final Mark leftMark = markPair.getFirst();
-            final Mark rightMark = markPair.getSecond();
+            Mark leftMark = markPair.getFirst();
+            Mark rightMark = markPair.getSecond();
 
             if (!leftMark.coincidesWith(currNode.getMark())) {
                 result = true;
                 currNode.setMark(leftMark);
-                worklist.addFirst(currNode);
+                worklist.addFirst((T)currNode);
             }
 
             if (!rightMark.coincidesWith(nextNode.getMark())) {
                 result = true;
                 nextNode.setMark(rightMark);
-                worklist.addFirst(nextNode);
+                worklist.addFirst((T)nextNode);
             }
         }
 
         return result;
     }
 
-    public static <T extends MarkedNode> boolean doOneEnd(final LinkedList<T> init, final OneEndFunctor functor) {
+    public static <T extends MarkedNode> boolean doOneEnd(List<T> init, OneEndFunctor functor) {
         boolean result = false;
 
-        final LinkedList<T> worklist = new LinkedList<T>();
+        List<T> worklist = new LinkedList<>();
 
-        for (Iterator<T> i = init.iterator(); i.hasNext(); ) {
-            result = stepOneEnd(i.next(), worklist, functor) || result;
+        for (T anInit : init) {
+            result = stepOneEnd(anInit, worklist, functor) || result;
         }
 
         while (worklist.size() > 0) {
@@ -88,13 +88,13 @@ public static <T extends MarkedNode> boolean doOneEnd(final LinkedList<T> init,
         return result;
     }
 
-    public static <T extends MarkedNode> boolean doTwoEnds(final LinkedList<T> init, final TwoEndsFunctor functor) {
+    public static <T extends MarkedNode> boolean doTwoEnds(LinkedList<T> init, TwoEndsFunctor functor) {
         boolean result = false;
 
-        final LinkedList<T> worklist = new LinkedList<T>();
+        LinkedList<T> worklist = new LinkedList<>();
 
-        for (Iterator<T> i = init.iterator(); i.hasNext(); ) {
-            result = stepTwoEnds(i.next(), worklist, functor) || result;
+        for (T anInit : init) {
+            result = stepTwoEnds(anInit, worklist, functor) || result;
         }
 
         while (worklist.size() > 0) {