/*
* FindBugs - Find Bugs in Java programs
* Copyright (C) 2005, University of Maryland
*
* 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;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.NoSuchElementException;
import edu.umd.cs.findbugs.model.ClassNameRewriter;
/**
* A slightly more intellegent way of comparing BugInstances from two versions
* to see if they are the "same". Uses class and method hashes to try to handle
* renamings, at least for simple cases. (<em>Hashes disabled for the
* time being.</em>) Uses opcode context to try to identify code that is the
* same, even if it moves within the method. Also compares by bug abbreviation
* rather than bug type, since the "same" bug can change type if the context
* changes (e.g., "definitely null" to "null on simple path" for a null pointer
* dereference). Also, we often change bug types between different versions of
* FindBugs.
*
* @see edu.umd.cs.findbugs.BugInstance
* @see edu.umd.cs.findbugs.VersionInsensitiveBugComparator
* @author David Hovemeyer
*/
public class FuzzyBugComparator implements WarningComparator {
private static final boolean DEBUG = false;
// Don't use hashes for now. Still ironing out issues there.
private static final boolean USE_HASHES = false;
private static final long serialVersionUID = 1L;
/**
* Filter ignored BugAnnotations from given Iterator.
*/
private static class FilteringBugAnnotationIterator implements Iterator<BugAnnotation> {
Iterator<BugAnnotation> iter;
BugAnnotation next;
public FilteringBugAnnotationIterator(Iterator<BugAnnotation> iter) {
this.iter = iter;
}
private void findNext() {
if (next == null) {
while (iter.hasNext()) {
BugAnnotation candidate = iter.next();
if (!ignore(candidate)) {
next = candidate;
break;
}
}
}
}
/*
* (non-Javadoc)
*
* @see java.util.Iterator#hasNext()
*/
public boolean hasNext() {
findNext();
return next != null;
}
/*
* (non-Javadoc)
*
* @see java.util.Iterator#next()
*/
public BugAnnotation next() {
findNext();
if (next == null)
throw new NoSuchElementException();
BugAnnotation result = next;
next = null;
return result;
}
/*
* (non-Javadoc)
*
* @see java.util.Iterator#remove()
*/
public void remove() {
throw new UnsupportedOperationException();
}
}
/**
* Keep track of which BugCollections the various BugInstances have come
* from.
*/
private IdentityHashMap<BugInstance, BugCollection> bugCollectionMap;
private ClassNameRewriter classNameRewriter;
/**
* Map of class hashes to canonicate class names used for comparison
* purposes.
*/
// private Map<ClassHash, String> classHashToCanonicalClassNameMap;
public FuzzyBugComparator() {
if (DEBUG)
System.out.println("Created fuzzy comparator");
this.bugCollectionMap = new IdentityHashMap<BugInstance, BugCollection>();
// this.classHashToCanonicalClassNameMap = new TreeMap<ClassHash,
// String>();
}
/**
* Register a BugCollection. This allows us to find the class and method
* hashes for BugInstances to be compared.
*
* @param bugCollection
* a BugCollection
*/
public void registerBugCollection(BugCollection bugCollection) {
// For now, nothing to do
}
/*
* (non-Javadoc)
*
* @see
* edu.umd.cs.findbugs.WarningComparator#setClassNameRewriter(edu.umd.cs
* .findbugs.model.MovedClassMap)
*/
public void setClassNameRewriter(ClassNameRewriter classNameRewriter) {
this.classNameRewriter = classNameRewriter;
}
public int compare(BugInstance lhs, BugInstance rhs) {
int cmp;
if (DEBUG)
System.out.println("Fuzzy comparison");
// Bug abbreviations must match.
BugPattern lhsPattern = lhs.getBugPattern();
BugPattern rhsPattern = rhs.getBugPattern();
if (lhsPattern == null || rhsPattern == null) {
if (DEBUG) {
if (lhsPattern == null)
System.out.println("Missing pattern: " + lhs.getType());
if (rhsPattern == null)
System.out.println("Missing pattern: " + rhs.getType());
}
String lhsCode = getCode(lhs.getType());
String rhsCode = getCode(rhs.getType());
if ((cmp = lhsCode.compareTo(rhsCode)) != 0)
return cmp;
} else {
if ((cmp = lhsPattern.getAbbrev().compareTo(rhsPattern.getAbbrev())) != 0)
return cmp;
}
BugCollection lhsCollection = bugCollectionMap.get(lhs);
BugCollection rhsCollection = bugCollectionMap.get(rhs);
// Scan through bug annotations, comparing fuzzily if possible
Iterator<BugAnnotation> lhsIter = new FilteringBugAnnotationIterator(lhs.annotationIterator());
Iterator<BugAnnotation> rhsIter = new FilteringBugAnnotationIterator(rhs.annotationIterator());
while (lhsIter.hasNext() && rhsIter.hasNext()) {
BugAnnotation lhsAnnotation = lhsIter.next();
BugAnnotation rhsAnnotation = rhsIter.next();
if (DEBUG)
System.out.println("Compare annotations: " + lhsAnnotation + "," + rhsAnnotation);
// Annotation classes must match exactly
cmp = lhsAnnotation.getClass().getName().compareTo(rhsAnnotation.getClass().getName());
if (cmp != 0) {
if (DEBUG)
System.out.println("annotation class mismatch: " + lhsAnnotation.getClass().getName() + ","
+ rhsAnnotation.getClass().getName());
return cmp;
}
if (lhsAnnotation.getClass() == ClassAnnotation.class)
cmp = compareClasses(lhsCollection, rhsCollection, (ClassAnnotation) lhsAnnotation,
(ClassAnnotation) rhsAnnotation);
else if (lhsAnnotation.getClass() == MethodAnnotation.class)
cmp = compareMethods(lhsCollection, rhsCollection, (MethodAnnotation) lhsAnnotation,
(MethodAnnotation) rhsAnnotation);
else if (lhsAnnotation.getClass() == SourceLineAnnotation.class)
cmp = compareSourceLines(lhsCollection, rhsCollection, (SourceLineAnnotation) lhsAnnotation,
(SourceLineAnnotation) rhsAnnotation);
else
// everything else just compare directly
cmp = lhsAnnotation.compareTo(rhsAnnotation);
if (cmp != 0)
return cmp;
}
// Number of bug annotations must match
if (!lhsIter.hasNext() && !rhsIter.hasNext()) {
if (DEBUG)
System.out.println("Match!");
return 0;
} else
return (lhsIter.hasNext() ? 1 : -1);
}
/**
* @param type
* @return the code of the Bug
*/
private String getCode(String type) {
int bar = type.indexOf('_');
if (bar < 0)
return "";
else
return type.substring(0, bar);
}
private static int compareNullElements(Object a, Object b) {
if (a != null)
return 1;
else if (b != null)
return -1;
else
return 0;
}
public int compareClasses(BugCollection lhsCollection, BugCollection rhsCollection, ClassAnnotation lhsClass,
ClassAnnotation rhsClass) {
if (lhsClass == null || rhsClass == null) {
return compareNullElements(lhsClass, rhsClass);
} else {
return compareClassesByName(lhsCollection, rhsCollection, lhsClass.getClassName(), rhsClass.getClassName());
}
}
// Compare classes: either exact fully qualified name must match, or class
// hash must match
public int compareClassesByName(BugCollection lhsCollection, BugCollection rhsCollection, String lhsClassName,
String rhsClassName) {
lhsClassName = rewriteClassName(lhsClassName);
rhsClassName = rewriteClassName(rhsClassName);
return lhsClassName.compareTo(rhsClassName);
}
/**
* @param className
* @return the rewritten class name
*/
private String rewriteClassName(String className) {
if (classNameRewriter != null) {
className = classNameRewriter.rewriteClassName(className);
}
return className;
}
// Compare methods: either exact name and signature must match, or method
// hash must match
public int compareMethods(BugCollection lhsCollection, BugCollection rhsCollection, MethodAnnotation lhsMethod,
MethodAnnotation rhsMethod) {
if (lhsMethod == null || rhsMethod == null) {
return compareNullElements(lhsMethod, rhsMethod);
}
// Compare for exact match
int cmp = lhsMethod.compareTo(rhsMethod);
return cmp;
}
/**
* For now, just look at the 2 preceeding and succeeding opcodes for fuzzy
* source line matching.
*/
private static final int NUM_CONTEXT_OPCODES = 2;
/**
* Compare source line annotations.
*
* @param rhsCollection
* lhs BugCollection
* @param lhsCollection
* rhs BugCollection
* @param lhs
* a SourceLineAnnotation
* @param rhs
* another SourceLineAnnotation
* @return comparison of lhs and rhs
*/
public int compareSourceLines(BugCollection lhsCollection, BugCollection rhsCollection, SourceLineAnnotation lhs,
SourceLineAnnotation rhs) {
if (lhs == null || rhs == null) {
return compareNullElements(lhs, rhs);
}
// Classes must match fuzzily.
int cmp = compareClassesByName(lhsCollection, rhsCollection, lhs.getClassName(), rhs.getClassName());
if (cmp != 0)
return cmp;
return 0;
}
// See "FindBugsAnnotationDescriptions.properties"
private static final HashSet<String> significantDescriptionSet = new HashSet<String>();
static {
// Classes, methods, and fields are significant.
significantDescriptionSet.add("CLASS_DEFAULT");
significantDescriptionSet.add("CLASS_EXCEPTION");
significantDescriptionSet.add("CLASS_REFTYPE");
significantDescriptionSet.add(ClassAnnotation.SUPERCLASS_ROLE);
significantDescriptionSet.add(ClassAnnotation.IMPLEMENTED_INTERFACE_ROLE);
significantDescriptionSet.add(ClassAnnotation.INTERFACE_ROLE);
significantDescriptionSet.add("METHOD_DEFAULT");
significantDescriptionSet.add(MethodAnnotation.METHOD_CALLED);
significantDescriptionSet.add("METHOD_DANGEROUS_TARGET"); // but do NOT
// use safe
// targets
significantDescriptionSet.add("METHOD_DECLARED_NONNULL");
significantDescriptionSet.add("FIELD_DEFAULT");
significantDescriptionSet.add("FIELD_ON");
significantDescriptionSet.add("FIELD_SUPER");
significantDescriptionSet.add("FIELD_MASKED");
significantDescriptionSet.add("FIELD_MASKING");
significantDescriptionSet.add("FIELD_STORED");
significantDescriptionSet.add("TYPE_DEFAULT");
significantDescriptionSet.add("TYPE_EXPECTED");
significantDescriptionSet.add("TYPE_FOUND");
significantDescriptionSet.add("LOCAL_VARIABLE_NAMED");
// Many int annotations are NOT significant: e.g., sync %, biased locked
// %, bytecode offset, etc.
// The null parameter annotations, however, are definitely significant.
significantDescriptionSet.add("INT_NULL_ARG");
significantDescriptionSet.add("INT_MAYBE_NULL_ARG");
significantDescriptionSet.add("INT_NONNULL_PARAM");
// Only DEFAULT source line annotations are significant.
significantDescriptionSet.add("SOURCE_LINE_DEFAULT");
}
public static boolean ignore(BugAnnotation annotation) {
return !significantDescriptionSet.contains(annotation.getDescription());
}
}