/*
* FindBugs - Find bugs in Java programs
* Copyright (C) 2004-2006 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.detect;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import org.apache.bcel.classfile.Code;
import edu.umd.cs.findbugs.BugAccumulator;
import edu.umd.cs.findbugs.BugInstance;
import edu.umd.cs.findbugs.BugReporter;
import edu.umd.cs.findbugs.ClassAnnotation;
import edu.umd.cs.findbugs.FirstPassDetector;
import edu.umd.cs.findbugs.MethodAnnotation;
import edu.umd.cs.findbugs.OpcodeStack.Item;
import edu.umd.cs.findbugs.Priorities;
import edu.umd.cs.findbugs.ba.AnalysisContext;
import edu.umd.cs.findbugs.ba.EqualsKindSummary;
import edu.umd.cs.findbugs.ba.Hierarchy2;
import edu.umd.cs.findbugs.ba.XClass;
import edu.umd.cs.findbugs.ba.XField;
import edu.umd.cs.findbugs.ba.XMethod;
import edu.umd.cs.findbugs.ba.ch.Subtypes2;
import edu.umd.cs.findbugs.bcel.OpcodeStackDetector;
import edu.umd.cs.findbugs.classfile.CheckedAnalysisException;
import edu.umd.cs.findbugs.classfile.ClassDescriptor;
import edu.umd.cs.findbugs.classfile.Global;
import edu.umd.cs.findbugs.classfile.MethodDescriptor;
public class OverridingEqualsNotSymmetrical extends OpcodeStackDetector implements FirstPassDetector {
private static final String EQUALS_NAME = "equals";
private static final String EQUALS_SIGNATURE = "(Ljava/lang/Object;)Z";
private static final String STATIC_EQUALS_SIGNATURE = "(Ljava/lang/Object;Ljava/lang/Object;)Z";
Map<ClassDescriptor, Set<ClassDescriptor>> classesWithGetClassBasedEquals = new HashMap<ClassDescriptor, Set<ClassDescriptor>>();
Map<ClassDescriptor, Set<ClassDescriptor>> classesWithInstanceOfBasedEquals = new HashMap<ClassDescriptor, Set<ClassDescriptor>>();
Map<ClassAnnotation, ClassAnnotation> parentMap = new TreeMap<ClassAnnotation, ClassAnnotation>();
Map<ClassAnnotation, MethodDescriptor> equalsMethod = new TreeMap<ClassAnnotation, MethodDescriptor>();
final BugReporter bugReporter;
final BugAccumulator bugAccumulator;
final EqualsKindSummary equalsKindSummary;
public OverridingEqualsNotSymmetrical(BugReporter bugReporter) {
this.bugReporter = bugReporter;
this.bugAccumulator = new BugAccumulator(bugReporter);
equalsKindSummary = AnalysisContext.currentAnalysisContext().getEqualsKindSummary();
}
@Override
public void visit(Code obj) {
if (getMethodName().equals(EQUALS_NAME) && !getMethod().isStatic() && getMethod().isPublic()
&& getMethodSig().equals(EQUALS_SIGNATURE)) {
sawCheckedCast = sawSuperEquals = sawInstanceOf = sawGetClass = sawReturnSuper = sawCompare = sawReturnNonSuper = prevWasSuperEquals = sawGoodEqualsClass = sawBadEqualsClass = dangerDanger = sawInstanceOfSupertype = alwaysTrue = alwaysFalse = sawStaticDelegate = sawEqualsBuilder = false;
sawInitialIdentityCheck = obj.getCode().length == 11 || obj.getCode().length == 9;
equalsCalls = 0;
super.visit(obj);
EqualsKindSummary.KindOfEquals kind = EqualsKindSummary.KindOfEquals.UNKNOWN;
if (alwaysTrue) {
kind = EqualsKindSummary.KindOfEquals.ALWAYS_TRUE;
} else if (alwaysFalse) {
kind = EqualsKindSummary.KindOfEquals.ALWAYS_FALSE;
} else if (sawReturnSuper && !sawReturnNonSuper) {
kind = EqualsKindSummary.KindOfEquals.RETURNS_SUPER;
} else if (sawSuperEquals) {
kind = EqualsKindSummary.KindOfEquals.INVOKES_SUPER;
} else if (sawInstanceOfSupertype) {
kind = EqualsKindSummary.KindOfEquals.INSTANCE_OF_SUPERCLASS_EQUALS;
} else if (sawInstanceOf) {
kind = getThisClass().isAbstract() ? EqualsKindSummary.KindOfEquals.ABSTRACT_INSTANCE_OF
: EqualsKindSummary.KindOfEquals.INSTANCE_OF_EQUALS;
} else if (sawGetClass && sawGoodEqualsClass) {
kind = getThisClass().isAbstract() ? EqualsKindSummary.KindOfEquals.ABSTRACT_GETCLASS_GOOD_EQUALS
: EqualsKindSummary.KindOfEquals.GETCLASS_GOOD_EQUALS;
} else if (sawGetClass && sawBadEqualsClass) {
kind = EqualsKindSummary.KindOfEquals.GETCLASS_BAD_EQUALS;
} else if (equalsCalls == 1 || sawStaticDelegate || sawEqualsBuilder) {
kind = EqualsKindSummary.KindOfEquals.DELEGATE_EQUALS;
} else if (sawInitialIdentityCheck) {
kind = EqualsKindSummary.KindOfEquals.TRIVIAL_EQUALS;
} else if (sawCheckedCast) {
kind = EqualsKindSummary.KindOfEquals.CHECKED_CAST_EQUALS;
} else if (sawCompare) {
kind = EqualsKindSummary.KindOfEquals.COMPARE_EQUALS;
} else {
if (AnalysisContext.currentAnalysisContext().isApplicationClass(getThisClass())) {
bugReporter
.reportBug(new BugInstance(this, "EQ_UNUSUAL", Priorities.NORMAL_PRIORITY).addClassAndMethod(this));
}
}
ClassAnnotation classAnnotation = new ClassAnnotation(getDottedClassName());
equalsKindSummary.put(classAnnotation, kind);
count(kind);
if (kind == EqualsKindSummary.KindOfEquals.GETCLASS_GOOD_EQUALS
|| kind == EqualsKindSummary.KindOfEquals.ABSTRACT_GETCLASS_GOOD_EQUALS
|| kind == EqualsKindSummary.KindOfEquals.GETCLASS_BAD_EQUALS) {
ClassDescriptor classDescriptor = getClassDescriptor();
try {
Set<ClassDescriptor> subtypes = AnalysisContext.currentAnalysisContext().getSubtypes2()
.getSubtypes(classDescriptor);
if (subtypes.size() > 1) {
classesWithGetClassBasedEquals.put(classDescriptor, subtypes);
}
} catch (ClassNotFoundException e) {
assert true;
}
}
if (kind == EqualsKindSummary.KindOfEquals.INSTANCE_OF_EQUALS
|| kind == EqualsKindSummary.KindOfEquals.ABSTRACT_INSTANCE_OF) {
ClassDescriptor classDescriptor = getClassDescriptor();
try {
Set<ClassDescriptor> subtypes = AnalysisContext.currentAnalysisContext().getSubtypes2()
.getSubtypes(classDescriptor);
if (subtypes.size() > 1) {
classesWithInstanceOfBasedEquals.put(classDescriptor, subtypes);
}
} catch (ClassNotFoundException e) {
assert true;
}
}
String superClassName = getSuperclassName().replace('/', '.');
if (!superClassName.equals("java.lang.Object")) {
parentMap.put(classAnnotation, new ClassAnnotation(superClassName));
}
equalsMethod.put(classAnnotation, getMethodDescriptor());
}
bugAccumulator.reportAccumulatedBugs();
}
boolean sawInstanceOf, sawInstanceOfSupertype, sawCheckedCast;
boolean sawGetClass;
boolean sawReturnSuper;
boolean sawSuperEquals;
boolean sawReturnNonSuper;
boolean prevWasSuperEquals;
boolean sawInitialIdentityCheck;
boolean alwaysTrue, alwaysFalse;
int equalsCalls;
boolean sawGoodEqualsClass, sawBadEqualsClass;
boolean sawCompare;
boolean dangerDanger = false;
boolean sawStaticDelegate;
boolean sawEqualsBuilder;
private final EnumMap<EqualsKindSummary.KindOfEquals, Integer> count = new EnumMap<EqualsKindSummary.KindOfEquals, Integer>(
EqualsKindSummary.KindOfEquals.class);
private void count(EqualsKindSummary.KindOfEquals k) {
Integer v = count.get(k);
if (v == null) {
count.put(k, 1);
} else {
count.put(k, v + 1);
}
}
@Override
public void sawOpcode(int seen) {
if (getPC() == 2 && seen != IF_ACMPEQ && seen != IF_ACMPNE) {
// System.out.println(OPCODE_NAMES[seen]);
sawInitialIdentityCheck = false;
}
if (getPC() == 2
&& seen == INVOKESTATIC
&& getCode().getCode().length == 6
&& (getPrevOpcode(1) == ALOAD_0 && getPrevOpcode(2) == ALOAD_1 || getPrevOpcode(1) == ALOAD_1
&& getPrevOpcode(2) == ALOAD_0)) {
sawStaticDelegate = true;
}
if ((seen == INVOKESTATIC || seen == INVOKESPECIAL || seen == INVOKEVIRTUAL)
&& (getClassConstantOperand().equals("org/apache/commons/lang/builder/EqualsBuilder")
|| getClassConstantOperand().equals("org/apache/commons/lang3/builder/EqualsBuilder"))) {
sawEqualsBuilder = true;
}
if (seen == IRETURN && getPC() == 1 && getPrevOpcode(1) == ICONST_0) {
alwaysFalse = true;
if (AnalysisContext.currentAnalysisContext().isApplicationClass(getThisClass())) {
bugReporter.reportBug(new BugInstance(this, "EQ_ALWAYS_FALSE", Priorities.HIGH_PRIORITY).addClassAndMethod(this)
.addSourceLine(this));
}
}
if (seen == IRETURN && getPC() == 1 && getPrevOpcode(1) == ICONST_1) {
alwaysTrue = true;
if (AnalysisContext.currentAnalysisContext().isApplicationClass(getThisClass())) {
bugReporter.reportBug(new BugInstance(this, "EQ_ALWAYS_TRUE", Priorities.HIGH_PRIORITY).addClassAndMethod(this)
.addSourceLine(this));
}
}
if (seen == IF_ACMPEQ || seen == IF_ACMPNE) {
checkForComparingClasses();
}
if (callToInvoke(seen)) {
equalsCalls++;
checkForComparingClasses();
if (AnalysisContext.currentAnalysisContext().isApplicationClass(getThisClass()) && dangerDanger) {
bugReporter.reportBug(new BugInstance(this, "EQ_COMPARING_CLASS_NAMES", Priorities.NORMAL_PRIORITY)
.addClassAndMethod(this).addSourceLine(this));
}
}
if ((seen == INVOKEINTERFACE || seen == INVOKEVIRTUAL) && getNameConstantOperand().equals("compare")
&& stack.getStackDepth() >= 2) {
Item left = stack.getStackItem(1);
Item right = stack.getStackItem(0);
if (left.getRegisterNumber() + right.getRegisterNumber() == 1) {
sawCompare = true;
}
}
dangerDanger = false;
if (seen == INVOKEVIRTUAL && getClassConstantOperand().equals("java/lang/Class")
&& getNameConstantOperand().equals("getName") && getSigConstantOperand().equals("()Ljava/lang/String;")
&& stack.getStackDepth() >= 2) {
Item left = stack.getStackItem(1);
XMethod leftM = left.getReturnValueOf();
Item right = stack.getStackItem(0);
XMethod rightM = right.getReturnValueOf();
if (leftM != null && rightM != null && leftM.getName().equals("getName") && rightM.getName().equals("getClass")) {
dangerDanger = true;
}
}
if (seen == INVOKESPECIAL && getNameConstantOperand().equals(EQUALS_NAME)
&& getSigConstantOperand().equals(EQUALS_SIGNATURE)) {
sawSuperEquals = prevWasSuperEquals = true;
} else {
if (seen == IRETURN) {
if (prevWasSuperEquals) {
sawReturnSuper = true;
} else {
sawReturnNonSuper = true;
}
}
prevWasSuperEquals = false;
}
if (seen == INSTANCEOF && stack.getStackDepth() > 0 && stack.getStackItem(0).getRegisterNumber() == 1) {
ClassDescriptor instanceOfCheck = getClassDescriptorOperand();
if (instanceOfCheck.equals(getClassDescriptor())) {
sawInstanceOf = true;
} else {
try {
if (AnalysisContext.currentAnalysisContext().getSubtypes2().isSubtype(getClassDescriptor(), instanceOfCheck)) {
sawInstanceOfSupertype = true;
}
} catch (ClassNotFoundException e) {
sawInstanceOfSupertype = true;
}
}
}
if (seen == CHECKCAST && stack.getStackDepth() > 0 && stack.getStackItem(0).getRegisterNumber() == 1) {
ClassDescriptor castTo = getClassDescriptorOperand();
if (castTo.equals(getClassDescriptor())) {
sawCheckedCast = true;
}
try {
if (AnalysisContext.currentAnalysisContext().getSubtypes2().isSubtype(getClassDescriptor(), castTo)) {
sawCheckedCast = true;
}
} catch (ClassNotFoundException e) {
sawCheckedCast = true;
}
}
if (seen == INVOKEVIRTUAL && getNameConstantOperand().equals("getClass")
&& getSigConstantOperand().equals("()Ljava/lang/Class;")) {
sawGetClass = true;
}
}
private boolean callToInvoke(int seen) {
if (seen == INVOKEVIRTUAL || seen == INVOKEINTERFACE || seen == INVOKESPECIAL) {
return invokesMethodWithEqualLikeName() && getSigConstantOperand().equals(EQUALS_SIGNATURE);
}
if (seen == INVOKESTATIC) {
String sig = getSigConstantOperand();
return invokesMethodWithEqualLikeName() && sig.endsWith("Ljava/lang/Object;)Z");
}
return false;
}
public boolean invokesMethodWithEqualLikeName() {
return getNameConstantOperand().toLowerCase().indexOf(EQUALS_NAME) >= 0;
}
/**
*
*/
private void checkForComparingClasses() {
if (stack.getStackDepth() >= 2) {
Item left = stack.getStackItem(1);
XMethod leftM = left.getReturnValueOf();
Item right = stack.getStackItem(0);
XMethod rightM = right.getReturnValueOf();
if (left.getSignature().equals("Ljava/lang/Class;") && right.getSignature().equals("Ljava/lang/Class;")) {
boolean leftMatch = leftM != null && leftM.getName().equals("getClass");
boolean rightMatch = rightM != null && rightM.getName().equals("getClass");
if (leftMatch && rightMatch) {
sawGoodEqualsClass = true;
} else {
if (getClassName().equals(left.getConstant()) && rightMatch || leftMatch
&& getClassName().equals(right.getConstant())) {
if (getThisClass().isFinal()) {
sawGoodEqualsClass = true;
} else {
sawBadEqualsClass = true;
if (AnalysisContext.currentAnalysisContext().isApplicationClass(getThisClass())) {
int priority = Priorities.NORMAL_PRIORITY;
BugInstance bug = new BugInstance(this, "EQ_GETCLASS_AND_CLASS_CONSTANT", priority)
.addClassAndMethod(this);
try {
Subtypes2 subtypes2 = AnalysisContext.currentAnalysisContext().getSubtypes2();
Set<ClassDescriptor> subtypes = subtypes2.getDirectSubtypes(getClassDescriptor());
for (ClassDescriptor c : subtypes) {
try {
Global.getAnalysisCache().getClassAnalysis(XClass.class, c);
} catch (CheckedAnalysisException e) {
continue;
}
XMethod m = Hierarchy2.findMethod(c, "equals", "(Ljava/lang/Object;)Z", false);
if (m == null) {
bug.addClass(c).describe(ClassAnnotation.SUBCLASS_ROLE);
priority--;
bug.setPriority(priority);
}
}
} catch (ClassNotFoundException e) {
bugReporter.reportMissingClass(e);
}
bugAccumulator.accumulateBug(bug, this);
}
}
}
}
}
}
}
@Override
public void report() {
if (false) {
Subtypes2 subtypes2 = AnalysisContext.currentAnalysisContext().getSubtypes2();
for (Map.Entry<ClassDescriptor, Set<ClassDescriptor>> e : classesWithGetClassBasedEquals.entrySet()) {
ClassAnnotation parentClass = ClassAnnotation.fromClassDescriptor(e.getKey());
XClass xParent = AnalysisContext.currentXFactory().getXClass(e.getKey());
if (xParent == null) {
continue;
}
EqualsKindSummary.KindOfEquals parentKind = equalsKindSummary.get(parentClass);
for (ClassDescriptor child : e.getValue()) {
if (child.equals(e.getKey())) {
continue;
}
XClass xChild = AnalysisContext.currentXFactory().getXClass(child);
if (xChild == null) {
continue;
}
ClassAnnotation childClass = ClassAnnotation.fromClassDescriptor(child);
EqualsKindSummary.KindOfEquals childKind = equalsKindSummary.get(childClass);
int fieldsOfInterest = 0;
for (XField f : xChild.getXFields()) {
if (!f.isStatic() && !f.isSynthetic()) {
fieldsOfInterest++;
}
}
int grandchildren = -1;
try {
grandchildren = subtypes2.getSubtypes(child).size();
} catch (ClassNotFoundException e1) {
assert true;
}
System.out.println(parentKind + " " + childKind + " " + parentClass + " " + childClass + " "
+ fieldsOfInterest + " " + grandchildren);
try {
if (grandchildren >= 2) {
for (ClassDescriptor g : subtypes2.getSubtypes(child)) {
if (!g.equals(child)) {
System.out.println(" " + g);
}
}
}
} catch (ClassNotFoundException e1) {
assert true;
}
}
}
int overridden = 0, total = 0;
for (Map.Entry<ClassDescriptor, Set<ClassDescriptor>> e : classesWithInstanceOfBasedEquals.entrySet()) {
ClassAnnotation parentClass = ClassAnnotation.fromClassDescriptor(e.getKey());
XClass xParent = AnalysisContext.currentXFactory().getXClass(e.getKey());
if (xParent == null) {
continue;
}
EqualsKindSummary.KindOfEquals parentKind = equalsKindSummary.get(parentClass);
boolean isOverridden = false;
for (ClassDescriptor child : e.getValue()) {
if (child.equals(e.getKey())) {
continue;
}
XClass xChild = AnalysisContext.currentXFactory().getXClass(child);
if (xChild == null) {
continue;
}
ClassAnnotation childClass = ClassAnnotation.fromClassDescriptor(child);
EqualsKindSummary.KindOfEquals childKind = equalsKindSummary.get(childClass);
if (childKind != null) {
isOverridden = true;
}
}
total++;
if (isOverridden) {
overridden++;
}
System.out.println("IS_OVERRIDDEN: " + e.getKey().getClassName());
}
System.out.println("Instance of equals: " + total + " subclassed, " + overridden + " overrridden");
for (Map.Entry<EqualsKindSummary.KindOfEquals, Integer> e : count.entrySet()) {
System.out.println(e);
}
}
for (Map.Entry<ClassAnnotation, ClassAnnotation> e : parentMap.entrySet()) {
ClassAnnotation childClass = e.getKey();
EqualsKindSummary.KindOfEquals childKind = equalsKindSummary.get(childClass);
ClassAnnotation parentClass = e.getValue();
EqualsKindSummary.KindOfEquals parentKind = equalsKindSummary.get(parentClass);
if (childKind == EqualsKindSummary.KindOfEquals.INSTANCE_OF_EQUALS
&& parentKind == EqualsKindSummary.KindOfEquals.INSTANCE_OF_EQUALS) {
bugReporter.reportBug(new BugInstance(this, "EQ_OVERRIDING_EQUALS_NOT_SYMMETRIC", NORMAL_PRIORITY)
.add(childClass).addMethod(equalsMethod.get(childClass)).addMethod(equalsMethod.get(parentClass))
.describe(MethodAnnotation.METHOD_OVERRIDDEN));
}
}
}
}