Move methods to util classes

Author: PatrikScully

spotbugs/src/main/java/edu/umd/cs/findbugs/detect/AtomicOperationsCombinedDetector.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.Iterator;
@@ -63,9 +62,9 @@
 import edu.umd.cs.findbugs.ba.ca.CallListDataflow;
 import edu.umd.cs.findbugs.bcel.BCELUtil;
 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.CollectionAnalysis;
+import edu.umd.cs.findbugs.util.MethodAnalysis;
 
 public class AtomicOperationsCombinedDetector implements Detector {
 
@@ -157,11 +156,7 @@ private static boolean isInterestingField(ClassMember classMember) {
         if (classMember == null) {
             return false;
         }
-        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()))
+        return CollectionAnalysis.isSynchronizedCollection(classMember)
                 || (classMember.getClassName().startsWith("java.util.concurrent.atomic") && classMember.getSignature().endsWith(")V"));
     }
 
@@ -175,8 +170,6 @@ private void analyzeInterestingFields(ClassContext classContext, Method method)
         CallListDataflow callListDataflow = classContext.getCallListDataflow(method);
         JavaClass javaClass = classContext.getJavaClass();
         MethodDescriptor methodDescriptor = BCELUtil.getMethodDescriptor(javaClass, method);
-        FinallyDuplicatesInfoFactory.FinallyDuplicatesInfo methodAnalysis =
-                Global.getAnalysisCache().getMethodAnalysis(FinallyDuplicatesInfoFactory.FinallyDuplicatesInfo.class, methodDescriptor);
         boolean synchronizedBlock = false;
 
         for (Location location : cfg.orderedLocations()) {
@@ -189,7 +182,7 @@ private void analyzeInterestingFields(ClassContext classContext, Method method)
                 synchronizedBlock = true;
             } else if (instruction instanceof MONITOREXIT) {
                 synchronizedBlock = false;
-            } else if (instruction instanceof PUTFIELD && !synchronizedBlock && !isDuplicatedLocation(methodAnalysis, pc)) {
+            } else if (instruction instanceof PUTFIELD && !synchronizedBlock && !MethodAnalysis.isDuplicatedLocation(methodDescriptor, pc)) {
                 XField xField = XFactory.createXField((FieldInstruction) instruction, cpg);
                 if (interestingFields.contains(xField)) {
                     bugPrototype.invokedField = xField;
@@ -198,7 +191,7 @@ private void analyzeInterestingFields(ClassContext classContext, Method method)
                             .add(bugPrototype);
                 }
             } else if (instruction instanceof InvokeInstruction && !(instruction instanceof INVOKEDYNAMIC)
-                    && !synchronizedBlock && !isDuplicatedLocation(methodAnalysis, pc)) {
+                    && !synchronizedBlock && !MethodAnalysis.isDuplicatedLocation(methodDescriptor, pc)) {
                 OpcodeStack stack = OpcodeStackScanner.getStackAt(javaClass, method, pc);
                 Optional<XField> interestingField = getInterestingField(stack);
                 XMethod xMethod = XFactory.createXMethod((InvokeInstruction) instruction, cpg);
@@ -230,10 +223,6 @@ private void analyzeInterestingFields(ClassContext classContext, Method method)
         }
     }
 
-    private boolean isDuplicatedLocation(FinallyDuplicatesInfoFactory.FinallyDuplicatesInfo methodAnalysis, int pc) {
-        return methodAnalysis.getDuplicates(pc).stream().anyMatch(duplicatePc -> duplicatePc < pc);
-    }
-
     private Optional<XField> getInterestingField(OpcodeStack stack) {
         if (stack.getStackDepth() > 1 && stack.getStackItem(0).getReturnValueOf() != null) {
             return Optional.empty();

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

@@ -0,0 +1,48 @@
+/*
+ * 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 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);
+    }
+}