Move methods to util classes

Author: PatrikScully

CHANGELOG.md

@@ -20,17 +20,17 @@ Currently the versioning policy of this project follows [Semantic Versioning v2.
 - Fix FP `EI_EXPOSE_REP` when there are multiple immutable assignments ([#3023](https://github.com/spotbugs/spotbugs/issues/3023))
 - Fixed false positive `NP_NONNULL_FIELD_NOT_INITIALIZED_IN_CONSTRUCTOR` for Kotlin, handle Kotlin's `Intrinsics.checkNotNullParameter()` ([#3094](https://github.com/spotbugs/spotbugs/issues/3094))
 
+### Added
+- New detector `ResourceInMultipleThreadsDetector` and introduced new bug type:
+  - `AT_UNSAFE_RESOURCE_ACCESS_IN_THREAD` is reported in case of unsafe resource access in multiple threads.
+
 ## 4.8.6 - 2024-06-17
 ### Fixed
 - Do not report BC_UNCONFIRMED_CAST for Java 21's type switches when the switch instruction is TABLESWITCH ([#2782](https://github.com/spotbugs/spotbugs/issues/2782))
 - Do not throw exception when inspecting empty switch statements ([#2995](https://github.com/spotbugs/spotbugs/issues/2995))
 - Adjust priority since relaxed mode reports even `IGNORED_PRIORITY` ([#2994](https://github.com/spotbugs/spotbugs/issues/2994))
 - Fix duplicated log4j2 jar in distribution ([#3001](https://github.com/spotbugs/spotbugs/issues/3001))
 
-### Added
-- New detector `ResourceInMultipleThreadsDetector` and introduced new bug type:
-  - `AT_UNSAFE_RESOURCE_ACCESS_IN_THREAD` is reported in case of unsafe resource access in multiple threads.
-
 ## 4.8.5 - 2024-05-03
 ### Fixed
 - Fix FP `SING_SINGLETON_GETTER_NOT_SYNCHRONIZED` with eager instances ([#2932](https://github.com/spotbugs/spotbugs/issues/2932))

spotbugs/src/main/java/edu/umd/cs/findbugs/detect/ResourceInMultipleThreadsDetector.java

@@ -18,7 +18,6 @@
 
 package edu.umd.cs.findbugs.detect;
 
-import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
@@ -37,16 +36,15 @@
 import edu.umd.cs.findbugs.BugInstance;
 import edu.umd.cs.findbugs.BugReporter;
 import edu.umd.cs.findbugs.OpcodeStack;
-import edu.umd.cs.findbugs.ba.ClassMember;
 import edu.umd.cs.findbugs.ba.XField;
 import edu.umd.cs.findbugs.ba.XMethod;
 import edu.umd.cs.findbugs.bcel.BCELUtil;
 import edu.umd.cs.findbugs.bcel.OpcodeStackDetector;
 import edu.umd.cs.findbugs.classfile.CheckedAnalysisException;
-import edu.umd.cs.findbugs.classfile.Global;
 import edu.umd.cs.findbugs.classfile.MethodDescriptor;
-import edu.umd.cs.findbugs.classfile.engine.bcel.FinallyDuplicatesInfoFactory;
 import edu.umd.cs.findbugs.util.BootstrapMethodsUtil;
+import edu.umd.cs.findbugs.util.CollectionAnalysis;
+import edu.umd.cs.findbugs.util.MethodAnalysis;
 import edu.umd.cs.findbugs.util.MutableClasses;
 
 public class ResourceInMultipleThreadsDetector extends OpcodeStackDetector {
@@ -146,17 +144,18 @@ private Optional<MethodDescriptor> getMethodFromBootstrap(JavaClass javaClass, C
 
     private void collectFieldsUsedInThreads(int seen) throws CheckedAnalysisException {
         if ((seen == Const.PUTFIELD || seen == Const.PUTSTATIC) && getStack().getStackDepth() > 0
-                && !isDuplicatedLocation(getMethodDescriptor(), getPC())
+                && !MethodAnalysis.isDuplicatedLocation(getMethodDescriptor(), getPC())
                 && methodsUsedInThreads.contains(getMethodDescriptor())) {
             OpcodeStack.Item stackItem = getStack().getStackItem(0);
-            if (stackItem.getReturnValueOf() != null && isSynchronizedCollection(stackItem.getReturnValueOf())) {
+            if (stackItem.getReturnValueOf() != null && CollectionAnalysis.isSynchronizedCollection(stackItem.getReturnValueOf())) {
                 synchronizedCollectionTypedFields.add(getXFieldOperand());
             } else if (!isAtomicTypedField(getXFieldOperand())
                     && !(Const.CONSTRUCTOR_NAME.equals(getMethodName()) || Const.STATIC_INITIALIZER_NAME.equals(getMethodName()))) {
                 createOrUpdateFieldData(getXFieldOperand(), true, getMethod(), getXMethodOperand());
             }
         } else if ((seen == Const.INVOKEVIRTUAL || seen == Const.INVOKEINTERFACE || seen == Const.INVOKESPECIAL || seen == Const.INVOKESTATIC)
-                && getXMethodOperand() != null && getStack().getStackDepth() > 0 && !isDuplicatedLocation(getMethodDescriptor(), getPC())
+                && getXMethodOperand() != null && getStack().getStackDepth() > 0
+                && !MethodAnalysis.isDuplicatedLocation(getMethodDescriptor(), getPC())
                 && methodsUsedInThreads.contains(getMethodDescriptor())) {
             // The field is accessed always be the last item in the stack, because the earlier elements are the arguments
             XField xField = getStack().getStackItem(getStack().getStackDepth() - 1).getXField();
@@ -166,34 +165,6 @@ && getXMethodOperand() != null && getStack().getStackDepth() > 0 && !isDuplicate
         }
     }
 
-    /**
-     * Check if the method is a synchronized collection method.
-     * @todo: This method should be moved to a utility class when VNA03-J detector is merged
-     *
-     * @param classMember the class member
-     * @return {@code true} if the method is a synchronized collection method, {@code false} otherwise
-     */
-    private static boolean isSynchronizedCollection(ClassMember classMember) {
-        Set<String> interestingCollectionMethodNames = new HashSet<>(Arrays.asList(
-                "synchronizedCollection", "synchronizedSet", "synchronizedSortedSet",
-                "synchronizedNavigableSet", "synchronizedList", "synchronizedMap",
-                "synchronizedSortedMap", "synchronizedNavigableMap"));
-        return "java.util.Collections".equals(classMember.getClassName()) && interestingCollectionMethodNames.contains(classMember.getName());
-    }
-
-    /**
-     * Check if the location is duplicated in the method.
-     * @todo: This method should be moved to a utility class when VNA03-J detector is merged
-     *
-     * @return {@code true} if the location is duplicated in the method, {@code false} otherwise
-     * @throws CheckedAnalysisException if an error occurs during the analysis
-     */
-    private static boolean isDuplicatedLocation(MethodDescriptor methodDescriptor, int pc) throws CheckedAnalysisException {
-        FinallyDuplicatesInfoFactory.FinallyDuplicatesInfo methodAnalysis = Global.getAnalysisCache().getMethodAnalysis(
-                FinallyDuplicatesInfoFactory.FinallyDuplicatesInfo.class, methodDescriptor);
-        return methodAnalysis.getDuplicates(pc).stream().anyMatch(duplicatePc -> duplicatePc < pc);
-    }
-
     private boolean isAtomicTypedField(XField xField) {
         return xField.getSignature().contains("java/util/concurrent/atomic") || synchronizedCollectionTypedFields.contains(xField);
     }

spotbugs/src/main/java/edu/umd/cs/findbugs/util/CollectionAnalysis.java

@@ -0,0 +1,30 @@
+package edu.umd.cs.findbugs.util;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+import edu.umd.cs.findbugs.ba.ClassMember;
+
+/**
+ * Utility class for analyzing collections.
+ */
+public final class CollectionAnalysis {
+
+    private CollectionAnalysis() {
+    }
+
+    /**
+     * Check if a class member is a synchronized collection.
+     *
+     * @param classMember the class member
+     * @return {@code true} if the class member is a synchronized collection, {@code false} otherwise
+     */
+    public static boolean isSynchronizedCollection(ClassMember classMember) {
+        Set<String> interestingCollectionMethodNames = new HashSet<>(Arrays.asList(
+                "synchronizedCollection", "synchronizedSet", "synchronizedSortedSet",
+                "synchronizedNavigableSet", "synchronizedList", "synchronizedMap",
+                "synchronizedSortedMap", "synchronizedNavigableMap"));
+        return "java.util.Collections".equals(classMember.getClassName()) && interestingCollectionMethodNames.contains(classMember.getName());
+    }
+}

spotbugs/src/main/java/edu/umd/cs/findbugs/util/MethodAnalysis.java

@@ -0,0 +1,45 @@
+/*
+ * SpotBugs - Find bugs in Java programs
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+package edu.umd.cs.findbugs.util;
+
+import edu.umd.cs.findbugs.classfile.CheckedAnalysisException;
+import edu.umd.cs.findbugs.classfile.Global;
+import edu.umd.cs.findbugs.classfile.MethodDescriptor;
+import edu.umd.cs.findbugs.classfile.engine.bcel.FinallyDuplicatesInfoFactory;
+
+/**
+ * Utility class for method analysis.
+ */
+public final class MethodAnalysis {
+
+    private MethodAnalysis() {
+    }
+
+    /**
+     * Check if the location is duplicated in the method.
+     *
+     * @return {@code true} if the location is duplicated in the method, {@code false} otherwise
+     * @throws CheckedAnalysisException if an error occurs during the analysis
+     */
+    public static boolean isDuplicatedLocation(MethodDescriptor methodDescriptor, int pc) throws CheckedAnalysisException {
+        FinallyDuplicatesInfoFactory.FinallyDuplicatesInfo methodAnalysis =
+                Global.getAnalysisCache().getMethodAnalysis(FinallyDuplicatesInfoFactory.FinallyDuplicatesInfo.class, methodDescriptor);
+        return methodAnalysis.getDuplicates(pc).stream().anyMatch(duplicatePc -> duplicatePc < pc);
+    }
+}