Fix javac --incremental by using jmake for dependency analysis

third_party/jmake/src/org/pantsbuild/jmake/CompatibilityChecker.java

+/* Copyright (c) 2002-2008 Sun Microsystems, Inc. All rights reserved
+ *
+ * This program is distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+package org.pantsbuild.jmake;
+
+import java.lang.reflect.Modifier;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * This class implements checking of source compatibility of classes and supporting operations
+ *
+ * @author Misha Dmitriev
+ *  12 March 2004
+ */
+public class CompatibilityChecker {
+
+    private PCDManager pcdm;
+    private RefClassFinder rf;
+    ClassInfo oldClassInfo = null;
+    ClassInfo newClassInfo = null;
+    private boolean versionsCompatible;
+    private boolean publicConstantChanged;
+
+    public CompatibilityChecker(PCDManager pcdm, boolean failOnDependentJar, boolean noWarnOnDependentJar) {
+        this.pcdm = pcdm;
+        publicConstantChanged = false;
+        rf = new RefClassFinder(pcdm, failOnDependentJar, noWarnOnDependentJar);
+    }
+
+    /**
+     * Compares the two class versions for the given PCDEntry. Returns true if all changes are source
+     * compatible, and false otherwise.
+     */
+    public boolean compareClassVersions(PCDEntry entry) {
+        // I once had the following optimization here with the comment "No sense to make any further checks if
+        // everything is recompiled anyway", but now I believe it's wrong. For each class that was found changed
+        // we need to know whether the new version is compatible with the old or not, since this may determine
+        // whether the new version of this class is promoted into the pdb or not (see PCDManager.updateClassInfoInPCD()).
+        // So, all changed classes should be checked just to correctly determine version compatibility.
+        // if (publicConstantChanged) return false;
+
+        oldClassInfo = pcdm.getClassInfoForPCDEntry(ClassInfo.VER_OLD, entry);
+        newClassInfo = pcdm.getClassInfoForPCDEntry(ClassInfo.VER_NEW, entry);
+
+        rf.initialize(oldClassInfo.name, entry.javaFileFullPath.endsWith(".jar"));
+        versionsCompatible = true;
+
+        checkAccessFlags();
+        checkSuperclasses();
+        checkImplementedInterfaces();
+        checkFields();
+        checkMethodsAndConstructors();
+
+        return versionsCompatible;
+    }
+
+    /** Find all dependent classes for a deleted class. */
+    public void checkDeletedClass(PCDEntry entry) {
+        oldClassInfo = entry.oldClassInfo;
+        rf.initialize(oldClassInfo.name, entry.javaFileFullPath.endsWith(".jar"));
+        rf.findReferencingClassesForDeletedClass(oldClassInfo);
+        // It may happen that the only reference to deleted class X is via "X.class" construct
+        String packageToLookIn =
+                oldClassInfo.isPublic() ? null : oldClassInfo.packageName;
+        rf.findClassesDeclaringField(("class$" + oldClassInfo.name).intern(), "java/lang/Class", true, packageToLookIn);
+        checkForFinalFields();
+    }
+
+    /** Returns the names of classes affected by source incompatible changes to the new version of the checked class. */
+    public String[] getAffectedClasses() {
+        return rf.getAffectedClassNames();
+    }
+
+    /** All of the following methods return true if no source incompatible changes found, and false otherwise */
+    private void checkAccessFlags() {
+        char oldClassFlags = oldClassInfo.accessFlags;
+        char newClassFlags = newClassInfo.accessFlags;
+        if (oldClassFlags == newClassFlags) {
+            return;
+        }
+
+        if (!Modifier.isFinal(oldClassFlags) && Modifier.isFinal(newClassFlags)) {
+            versionsCompatible = false;
+            rf.findDirectSubclasses(oldClassInfo);
+        }
+
+        if (!Modifier.isAbstract(oldClassFlags) && Modifier.isAbstract(newClassFlags)) {
+            versionsCompatible = false;
+            rf.findReferencingClasses0(oldClassInfo);
+        }
+
+        // Now to accessibility modifiers checking...
+        if (Modifier.isPublic(newClassFlags)) {
+            return;
+        }
+
+        if (Modifier.isProtected(newClassFlags)) {
+            if (Modifier.isPublic(oldClassFlags)) {
+                versionsCompatible = false;
+                rf.findDiffPackageAndNotSubReferencingClasses1(oldClassInfo);
+            }
+        } else if (Modifier.isPrivate(newClassFlags)) {
+            if (!Modifier.isPrivate(oldClassFlags)) {
+                versionsCompatible = false;
+            } else {
+                return;  // private -> private, nothing more to check
+            }
+            if (Modifier.isPublic(oldClassFlags)) {
+                rf.findReferencingClasses1(oldClassInfo);
+            } else if (Modifier.isProtected(oldClassFlags)) {
+                rf.findThisPackageOrSubReferencingClasses1(oldClassInfo);
+            } else {
+                rf.findThisPackageReferencingClasses1(oldClassInfo);
+            }
+        } else {  // newClassFlags has default access, since public has already been excluded
+            if (Modifier.isPublic(oldClassFlags)) {
+                versionsCompatible = false;
+                rf.findDiffPackageReferencingClasses1(oldClassInfo);
+            } else if (Modifier.isProtected(oldClassFlags)) {
+                versionsCompatible = false;
+                rf.findDiffPackageAndSubReferencingClasses1(oldClassInfo);
+            }
+        }
+    }
+
+    private void checkSuperclasses() {
+        List<String> oldSuperNames = oldClassInfo.getAllSuperclassNames();
+        List<String> newSuperNames = newClassInfo.getAllSuperclassNames();
+
+        int oldNamesSizeMinusOne = oldSuperNames.size() - 1;
+        for (int i = 0; i <= oldNamesSizeMinusOne; i++) {
+            String oldSuperName = oldSuperNames.get(i);
+            if (!newSuperNames.contains(oldSuperName)) {
+                versionsCompatible = false;
+                ClassInfo missingSuperClass =
+                        pcdm.getClassInfoForName(ClassInfo.VER_OLD, oldSuperName);
+                if (missingSuperClass == null) { // This class is not in project
+                    missingSuperClass =
+                            ClassPath.getClassInfoForName(oldSuperName, pcdm);
+                    if (missingSuperClass == null) {
+                        missingSuperClass = new ClassInfo(oldSuperName, pcdm);
+                    }
+                }
+                rf.findReferencingClasses2(missingSuperClass, oldClassInfo);
+            }
+        }
+
+        // Now check if the class is an exception, and its kind has changed from unchecked to checked
+        if (oldClassInfo.isInterface() || oldSuperNames.size() == 0) {
+            return;
+        }
+        if (!(oldSuperNames.contains("java/lang/RuntimeException") || oldSuperNames.contains("java/lang/Error"))) {
+            return;
+        }
+        if (!(newSuperNames.contains("java/lang/RuntimeException") || newSuperNames.contains("java/lang/Error"))) {
+            if (!newSuperNames.contains("java/lang/Throwable")) {
+                return;
+            }
+            // Ok, exception kind has changed from unchecked to checked.
+            versionsCompatible = false;
+            rf.findReferencingClasses0(oldClassInfo);
+            rf.findRefsToMethodsThrowingException(oldClassInfo);
+        }
+    }
+
+    private void checkImplementedInterfaces() {
+        Set<String> oldIntfNames = oldClassInfo.getAllImplementedIntfNames();
+        Set<String> newIntfNames = newClassInfo.getAllImplementedIntfNames();
+
+        for (String oldIntfName : oldIntfNames) {
+            if (!newIntfNames.contains(oldIntfName)) {
+                versionsCompatible = false;
+                ClassInfo missingSuperInterface =
+                        pcdm.getClassInfoForName(ClassInfo.VER_OLD, oldIntfName);
+                if (missingSuperInterface == null) { // This class is not in project
+                    missingSuperInterface =
+                            ClassPath.getClassInfoForName(oldIntfName, pcdm);
+                    if (missingSuperInterface == null) {
+                        missingSuperInterface = new ClassInfo(oldIntfName, pcdm);
+                    }
+                }
+                rf.findReferencingClasses2(missingSuperInterface, oldClassInfo);
+            }
+        }
+
+        // Check if the class is abstract, and an interface has been added to its list of implemented interfaces
+        if (newClassInfo.isAbstract()) {
+            for (String newIntfName : newIntfNames) {
+                if (!oldIntfNames.contains(newIntfName)) {
+                    versionsCompatible = false;
+                    rf.findConcreteSubclasses(oldClassInfo);
+                    break;
+                }
+            }
+        }
+    }
+
+    private void checkFields() {
+        String oFNames[] = oldClassInfo.fieldNames;
+        String oFSignatures[] = oldClassInfo.fieldSignatures;
+        char oFFlags[] = oldClassInfo.fieldAccessFlags;
+        String nFNames[] = newClassInfo.fieldNames;
+        String nFSignatures[] = newClassInfo.fieldSignatures;
+        char nFFlags[] = newClassInfo.fieldAccessFlags;
+        int oFLen = oFNames != null ? oFNames.length : 0;
+        int nFLen = nFNames != null ? nFNames.length : 0;
+
+        int oFMod, nFMod;
+        String oFName, oFSig, nFName;
+        int i, j, k, endIdx;
+        int nonMatchingNewFields = nFLen;
+
+        for (i = 0; i < oFLen; i++) {
+            oFMod = oFFlags[i];
+            if (Modifier.isPrivate(oFMod)) {
+                continue;  // Changes to private fields don't affect compatibility
+            }
+            oFName = oFNames[i];
+            oFSig = oFSignatures[i];
+            boolean found = false;
+
+            // Look for the same field in the new version considering name and type
+            endIdx = nFLen - 1;
+            k = i < nFLen ? i : endIdx;
+            for (j = 0; j < nFLen; j++) {
+                if (oFName.equals(nFNames[k]) &&
+                        oFSig.equals(nFSignatures[k])) {
+                    found = true;
+                    break;
+                }
+                if (k < endIdx) {
+                    k++;
+                } else {
+                    k = 0;
+                }
+            }
+
+            if (found) {
+                nonMatchingNewFields--;
+                nFMod = nFFlags[k];
+                checkFieldModifiers(oFMod, nFMod, i, k);
+                if (publicConstantChanged) {
+                    return;
+                }
+            } else { // Matching field not found
+                if (Modifier.isStatic(oFMod) && Modifier.isFinal(oFMod) &&
+                        oldClassInfo.primitiveConstantInitValues != null &&
+                        oldClassInfo.primitiveConstantInitValues[i] != null) {
+                    // Compile-time constant deleted
+                    versionsCompatible = false;
+                    rf.findAllProjectClasses(oldClassInfo, i);
+                    if (Modifier.isPublic(oFMod)) {
+                        publicConstantChanged = true;
+                        return;
+                    }
+                } else {
+                    versionsCompatible = false;
+                    rf.findReferencingClassesForField(oldClassInfo, i);
+                }
+            }
+        }
+
+        if (nonMatchingNewFields > 0) { // There are some fields declared in the new version which don't exist in the old one
+            // Look for fields hiding same-named fields in superclasses
+            for (i = 0; i < nFLen; i++) {
+                nFName = nFNames[i];
+
+                boolean found = false;
+                for (j = 0; j < oFLen; j++) {
+                    if (nFName.equals(oFNames[j])) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (found) {
+                    continue;  // nFName is not an added field
+                }
+                String superName = oldClassInfo.superName;
+                ClassInfo superInfo;
+                while (superName != null) {
+                    superInfo =
+                            pcdm.getClassInfoForName(ClassInfo.VER_OLD, superName);
+                    if (superInfo == null) {
+                        break;
+                    }
+                    String[] superOFNames = superInfo.fieldNames;
+                    int superOFNamesLen = superOFNames != null ? superOFNames.length
+                            : 0;
+                    for (j = 0; j < superOFNamesLen; j++) {
+                        if (nFName == superOFNames[j]) {
+                            versionsCompatible = false;
+                            rf.findReferencingClassesForField(superInfo, j);
+                        }
+                    }
+                    superName = superInfo.superName;
+                }
+            }
+        }
+    }
+
+    /** It is already known that old field is not private */
+    private void checkFieldModifiers(int oFMod, int nFMod, int oldFieldIdx, int newFieldIdx) {
+        if (oFMod == nFMod) {
+            if (Modifier.isFinal(oFMod) &&
+                    (!ClassInfo.constFieldInitValuesEqual(oldClassInfo, oldFieldIdx, newClassInfo, newFieldIdx))) {
+                versionsCompatible = false;
+                rf.findAllProjectClasses(oldClassInfo, oldFieldIdx);
+                if (Modifier.isPublic(oFMod)) {
+                    publicConstantChanged = true;  // Means we will have to recompile ALL project classes
+                }
+                return;
+            }
+        }
+
+        // These tests are ordered such that if a previous test succeeds, there is no need to do further tests, since that
+        // former test will cause more classes to be checked than any of the further tests. That is why it is possible to
+        // check properties that are in fact independent (e.g. accessibility vs. static/non-static) together. But this
+        // optimization only works since all kinds of tests result in the same kind of find..ReferencingClassesForField()
+        // outcome. For methods this is not true, and so there we have to check independent properties separately.
+        if (Modifier.isStatic(oFMod) && Modifier.isFinal(oFMod) && // oFMod is known to be non-private
+                (!Modifier.isFinal(nFMod) || !ClassInfo.constFieldInitValuesEqual(oldClassInfo, oldFieldIdx, newClassInfo, newFieldIdx))) {
+            versionsCompatible = false;
+            rf.findAllProjectClasses(oldClassInfo, oldFieldIdx);
+            if (Modifier.isPublic(oFMod)) {
+                publicConstantChanged = true;
+            }
+        } else if (Modifier.isPrivate(nFMod) || // oFMod is known to be non-private
+                (!Modifier.isFinal(oFMod) && Modifier.isFinal(nFMod)) ||
+                (Modifier.isStatic(oFMod) != Modifier.isStatic(nFMod)) ||
+                (Modifier.isVolatile(oFMod) != Modifier.isVolatile(nFMod))) {
+            versionsCompatible = false;
+            rf.findReferencingClassesForField(oldClassInfo, oldFieldIdx);
+        } else if (Modifier.isPublic(oFMod) && Modifier.isProtected(nFMod)) {
+            versionsCompatible = false;
+            rf.findDiffPackageReferencingClassesForField(oldClassInfo, oldFieldIdx);
+        } else if ((Modifier.isPublic(oFMod) || Modifier.isProtected(oFMod)) &&
+                (!(Modifier.isPublic(nFMod) || Modifier.isProtected(nFMod) || Modifier.isPrivate(nFMod)))) {
+            versionsCompatible = false;
+            if (Modifier.isPublic(oFMod)) {
+                rf.findDiffPackageReferencingClassesForField(oldClassInfo, oldFieldIdx);
+            } else {
+                rf.findDiffPackageAndSubReferencingClassesForField(oldClassInfo, oldFieldIdx);
+            }
+        }
+    }
+
+    private void checkForFinalFields() {
+        char oFFlags[] = oldClassInfo.fieldAccessFlags;
+        int oFLen = oldClassInfo.fieldNames != null ? oldClassInfo.fieldNames.length
+                : 0;
+        int oFMod;
+
+        for (int i = 0; i < oFLen; i++) {
+            oFMod = oFFlags[i];
+            if (Modifier.isPrivate(oFMod)) {
+                continue;  // Changes to private fields don't affect compatibility
+            }
+            if (Modifier.isStatic(oFMod) && Modifier.isFinal(oFMod)) {
+                rf.findAllProjectClasses(oldClassInfo, i);
+                if (Modifier.isPublic(oFMod)) {
+                    publicConstantChanged = true;
+                    return;
+                }
+            }
+        }
+    }
+
+    private void checkMethodsAndConstructors() {
+        String oMNames[] = oldClassInfo.methodNames;
+        String oMSignatures[] = oldClassInfo.methodSignatures;
+        char oMFlags[] = oldClassInfo.methodAccessFlags;
+        String nMNames[] = newClassInfo.methodNames;
+        String nMSignatures[] = newClassInfo.methodSignatures;
+        char nMFlags[] = newClassInfo.methodAccessFlags;
+        int oMLen = oMNames != null ? oMNames.length : 0;
+        int nMLen = nMNames != null ? nMNames.length : 0;
+
+        int oMMod, nMMod;
+        String oMName, oMSig, nMName, nMSig;
+        int i, j, k, endIdx;
+        int nonMatchingNewMethods = nMLen;
+
+        for (i = 0; i < oMLen; i++) {
+            oMMod = oMFlags[i];
+            if (Modifier.isPrivate(oMMod)) {
+                continue;  // Changes to private methods don't affect compatibility
+            }
+            oMName = oMNames[i];
+            oMSig = oMSignatures[i];
+            boolean found = false;
+
+            // Look for the same method in the new version considering name and signature
+            endIdx = nMLen - 1;
+            k = i < nMLen ? i : endIdx;
+            for (j = 0; j < nMLen; j++) {
+                if (oMName == nMNames[k] && oMSig == nMSignatures[k]) {
+                    found = true;
+                    break;
+                }
+                if (k < endIdx) {
+                    k++;
+                } else {
+                    k = 0;
+                }
+            }
+
+            if (found) {
+                nonMatchingNewMethods--;
+                nMMod = nMFlags[k];
+                if (oMMod != nMMod) {
+                    checkMethodModifiers(oMMod, nMMod, i);
+                }
+
+                // Check if the new method throws more exceptions than the old one
+                if (newClassInfo.checkedExceptions != null && newClassInfo.checkedExceptions[k] != null) {
+                    if (oldClassInfo.checkedExceptions == null) {
+                        versionsCompatible = false;
+                        rf.findReferencingClassesForMethod(oldClassInfo, i);
+                    } else if (oldClassInfo.checkedExceptions[i] == null) {
+                        versionsCompatible = false;
+                        rf.findReferencingClassesForMethod(oldClassInfo, i);
+                    } else {
+                        String oldExceptions[] =
+                                oldClassInfo.checkedExceptions[i];
+                        String newExceptions[] =
+                                newClassInfo.checkedExceptions[k];
+                        for (int ei = 0; ei < newExceptions.length; ei++) {
+                            String newEx = newExceptions[ei];
+                            found = false;
+                            for (int ej = 0; ej < oldExceptions.length; ej++) {
+                                if (newEx.equals(oldExceptions[ej])) {
+                                    found = true;
+                                    break;
+                                }
+                            }
+                            if (!found) {
+                                versionsCompatible = false;
+                                rf.findReferencingClassesForMethod(oldClassInfo, i);
+                                break;
+                            }
+                        }
+                    }
+                }
+            } else { // Matching method not found
+                versionsCompatible = false;
+                rf.findReferencingClassesForMethod(oldClassInfo, i);
+                // Deleting a concrete method from an abstract class is a special case
+                if (oldClassInfo.isAbstract() && !Modifier.isAbstract(oMMod)) {
+                    rf.findConcreteSubclassesNotOverridingAbstractMethod(oldClassInfo, oldClassInfo, i);
+                }
+            }
+        }
+
+        if (nonMatchingNewMethods > 0) {  // There are some methods/constructors declared in the new version which don't exist in the old one
+            if (!oldClassInfo.isInterface()) {
+                for (i = 0; i < nMLen; i++) {
+                    nMMod = nMFlags[i];
+                    if (Modifier.isPrivate(nMMod)) {
+                        continue;
+                    }
+                    String newMName = nMNames[i];
+                    final String newMSig = nMSignatures[i];
+                    final boolean isStatic = Modifier.isStatic(nMMod);
+
+                    boolean found = false;
+                    for (j = 0; j < oMLen; j++) {
+                        if (newMName.equals(oMNames[j]) &&
+                                newMSig.equals(oMSignatures[j])) {
+                            found = true;
+                            break;
+                        }
+                    }
+                    if (found) {
+                        continue;  // nMName is not an added method
+                    }
+                    // Check if the new method is a static one that hides an inherited static method
+                    // Check if the new method overloads an existing (declared or inherited) method. Overloading test is rough -
+                    // we just check if the number of parameters is the same. Note that if a new constructor has been added, it
+                    // can be treated in the same way, except that we shouldn't look up "same name methods" for it in superclasses.
+                    oldClassInfo.findExistingSameNameMethods(newMName,
+                            !newMName.equals("<init>"), false,
+                            new ClassInfo.MethodHandler() {
+
+                        void handleMethod(ClassInfo classInfo, int methodIdx) {
+                            String otherMSig =
+                                    classInfo.methodSignatures[methodIdx];
+                            if ((newMSig.equals(otherMSig) && isStatic &&
+                                    classInfo != oldClassInfo) ||
+                                    (newMSig != otherMSig &&
+                                    Utils.sameParamNumber(newMSig, otherMSig))) {
+                                versionsCompatible = false;
+                                rf.findReferencingClassesForMethod(classInfo, methodIdx);
+                            }
+                        }
+                    });
+
+                    if (Modifier.isAbstract(nMMod)) {
+                        // An abstract method added to the class. Find any concrete subclasses that don't override
+                        // or inherit a concrete implementation of this method.
+                        versionsCompatible = false;
+                        rf.findConcreteSubclassesNotOverridingAbstractMethod(oldClassInfo, newClassInfo, i);
+                    }
+                    // Check if there is a method with the same name in some subclass, such that it now overrides
+                    // or overloads the added method.
+                    if (subclassesDeclareSameNameMethod(oldClassInfo, newMName)) {
+                        versionsCompatible = false;
+                    }
+                }
+            } else {  // We are checking an interface.
+                for (i = 0; i < nMLen; i++) {
+                    String newMName = nMNames[i];
+                    final String newMSig = nMSignatures[i];
+
+                    boolean found = false;
+                    for (j = 0; j < oMLen; j++) {
+                        if (newMName == oMNames[j] && newMSig == oMSignatures[j]) {
+                            found = true;
+                            break;
+                        }
+                    }
+
+                    if (!found) {
+                        versionsCompatible = false;
+
+                        // Check if the new method overloads an existing (declared or inherited) method. Overloading test is rough -
+                        // we just check if the number of parameters is the same.
+                        oldClassInfo.findExistingSameNameMethods(newMName, true, true, new ClassInfo.MethodHandler() {
+
+                            void handleMethod(ClassInfo classInfo, int methodIdx) {
+                                String otherMSig =
+                                        classInfo.methodSignatures[methodIdx];
+                                if (newMSig != otherMSig &&
+                                        Utils.sameParamNumber(newMSig, otherMSig)) {
+                                    rf.findReferencingClassesForMethod(classInfo, methodIdx);
+                                }
+                            }
+                        });
+
+                        rf.findDirectlyAndOtherwiseImplementingConcreteClasses(oldClassInfo);
+                        rf.findAbstractSubtypesWithSameNameMethod(oldClassInfo, newMName, newMSig);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    private void checkMethodModifiers(int oMMod, int nMMod, int oldMethodIdx) {
+        if (Modifier.isPrivate(nMMod)) {
+            versionsCompatible = false;
+            rf.findReferencingClassesForMethod(oldClassInfo, oldMethodIdx);
+        } else if (Modifier.isPublic(oMMod) && Modifier.isProtected(nMMod)) {
+            versionsCompatible = false;
+            rf.findDiffPackageReferencingClassesForMethod(oldClassInfo, oldMethodIdx);
+        } else if ((Modifier.isPublic(oMMod) || Modifier.isProtected(oMMod)) &&
+                (!(Modifier.isPublic(nMMod) || Modifier.isProtected(nMMod) || Modifier.isPrivate(nMMod)))) {
+            versionsCompatible = false;
+            if (Modifier.isPublic(oMMod)) {
+                rf.findDiffPackageReferencingClassesForMethod(oldClassInfo, oldMethodIdx);
+            } else {
+                rf.findDiffPackageAndSubReferencingClassesForMethod(oldClassInfo, oldMethodIdx);
+            }
+        } else if ((Modifier.isPrivate(oMMod) && !Modifier.isPrivate(nMMod)) ||
+                (Modifier.isProtected(oMMod) && Modifier.isPublic(nMMod)) ||
+                (!(Modifier.isPublic(oMMod) || Modifier.isProtected(oMMod) || Modifier.isPrivate(oMMod)) &&
+                (Modifier.isPublic(nMMod) || Modifier.isProtected(nMMod)))) {
+            versionsCompatible = false;
+            rf.findSubclassesReimplementingMethod(oldClassInfo, oldMethodIdx);
+        }
+
+        if ((!Modifier.isAbstract(oMMod) && Modifier.isAbstract(nMMod)) ||
+                (Modifier.isStatic(oMMod) != Modifier.isStatic(nMMod))) {
+            versionsCompatible = false;
+            rf.findReferencingClassesForMethod(oldClassInfo, oldMethodIdx);
+            if (!Modifier.isAbstract(oMMod) && Modifier.isAbstract(nMMod)) {
+                rf.findConcreteSubclassesNotOverridingAbstractMethod(oldClassInfo, newClassInfo, oldMethodIdx);
+            }
+        }
+        if (!Modifier.isFinal(oMMod) && Modifier.isFinal(nMMod)) {
+            versionsCompatible = false;
+            rf.findSubclassesReimplementingMethod(oldClassInfo, oldMethodIdx);
+        }
+    }
+
+    /**
+     * Returns true if any subclass(es), direct or indirect, declare a method with name methodName.
+     * For each such occurence, referencing classes are looked up and added to the list of affected classes.
+     */
+    private boolean subclassesDeclareSameNameMethod(ClassInfo oldClassInfo, String methodName) {
+        boolean res = false;
+        ClassInfo[] directSubclasses = oldClassInfo.getDirectSubclasses();
+        for (int i = 0; i < directSubclasses.length; i++) {
+            ClassInfo subclass = directSubclasses[i];
+            int methNo = subclass.declaresSameNameMethod(methodName);
+            if (methNo >= 0) {
+                rf.addToAffectedClassNames(subclass.name);
+                rf.findReferencingClassesForMethod(subclass, methNo);
+                res = true;
+            }
+            if (subclassesDeclareSameNameMethod(subclass, methodName)) {
+                res = true;
+            }
+        }
+        return res;
+    }
+}