Buggy code:
public class MethodVerifier { SourceTypeBinding type ; HashtableOfObject inheritedMethods ; HashtableOfObject currentMethods ; LookupEnvironment environment ; private boolean allowCompatibleReturnTypes ; MethodVerifier ( LookupEnvironment environment ) { } boolean areMethodsCompatible ( MethodBinding one , MethodBinding two ) { } boolean areParametersEqual ( MethodBinding one , MethodBinding two ) { } boolean areReturnTypesCompatible ( MethodBinding one , MethodBinding two ) { } boolean areReturnTypesCompatible0 ( MethodBinding one , MethodBinding two ) { } boolean areTypesEqual ( TypeBinding one , TypeBinding two ) { } boolean canSkipInheritedMethods ( ) { } boolean canSkipInheritedMethods ( MethodBinding one , MethodBinding two ) { } void checkAbstractMethod ( MethodBinding abstractMethod ) { } void checkAgainstInheritedMethods ( MethodBinding currentMethod , MethodBinding [ ] methods , int length , MethodBinding [ ] allInheritedMethods ) { } void checkConcreteInheritedMethod ( MethodBinding concreteMethod , MethodBinding [ ] abstractMethods ) { } void checkExceptions ( MethodBinding newMethod , MethodBinding inheritedMethod ) { } void checkForBridgeMethod ( MethodBinding currentMethod , MethodBinding inheritedMethod , MethodBinding [ ] allInheritedMethods ) { } void checkForMissingHashCodeMethod ( ) { } void checkForRedundantSuperinterfaces ( ReferenceBinding superclass , ReferenceBinding [ ] superInterfaces ) { if ( superInterfaces == ( Binding . NO_SUPERINTERFACES ) ) return ; SimpleSet interfacesToCheck = new SimpleSet ( superInterfaces . length ) ; next : for ( int i = 0 , l = superInterfaces . length ; i < l ; i ++ ) { ReferenceBinding toCheck = superInterfaces [ i ] ; for ( int j = 0 ; j < l ; j ++ ) { if ( ( i != j ) && ( toCheck . implementsInterface ( superInterfaces [ j ] , true ) ) ) { TypeReference [ ] refs = this . type . scope . referenceContext . superInterfaces ; for ( int r = 0 , rl = refs . length ; r < rl ; r ++ ) { if ( ( refs [ r ] . resolvedType ) == toCheck ) { <START_BUG> problemReporter ( ) . redundantSuperInterface ( this . type , refs [ r ] , toCheck , superInterfaces [ j ] ) ; <END_BUG> continue next ; } } } } interfacesToCheck . add ( toCheck ) ; } ReferenceBinding [ ] itsInterfaces = null ; SimpleSet inheritedInterfaces = new SimpleSet ( 5 ) ; ReferenceBinding superType = superclass ; while ( ( superType != null ) && ( superType . isValidBinding ( ) ) ) { if ( ( itsInterfaces = superType . superInterfaces ( ) ) != ( Binding . NO_SUPERINTERFACES ) ) { for ( int i = 0 , l = itsInterfaces . length ; i < l ; i ++ ) { ReferenceBinding inheritedInterface = itsInterfaces [ i ] ; if ( ( ! ( inheritedInterfaces . includes ( inheritedInterface ) ) ) && ( inheritedInterface . isValidBinding ( ) ) ) { if ( interfacesToCheck . includes ( inheritedInterface ) ) { TypeReference [ ] refs = this . type . scope . referenceContext . superInterfaces ; for ( int r = 0 , rl = refs . length ; r < rl ; r ++ ) { if ( ( refs [ r ] . resolvedType ) == inheritedInterface ) { problemReporter ( ) . redundantSuperInterface ( this . type , refs [ r ] , inheritedInterface , superType ) ; break ; } } } else { inheritedInterfaces . add ( inheritedInterface ) ; } } } } superType = superType . superclass ( ) ; } int nextPosition = inheritedInterfaces . elementSize ; if ( nextPosition == 0 ) return ; ReferenceBinding [ ] interfacesToVisit = new ReferenceBinding [ nextPosition ] ; inheritedInterfaces . asArray ( interfacesToVisit ) ; for ( int i = 0 ; i < nextPosition ; i ++ ) { superType = interfacesToVisit [ i ] ; if ( ( itsInterfaces = superType . superInterfaces ( ) ) != ( Binding . NO_SUPERINTERFACES ) ) { int itsLength = itsInterfaces . length ; if ( ( nextPosition + itsLength ) >= ( interfacesToVisit . length ) ) System . arraycopy ( interfacesToVisit , 0 , ( interfacesToVisit = new ReferenceBinding [ ( nextPosition + itsLength ) + 5 ] ) , 0 , nextPosition ) ; for ( int a = 0 ; a < itsLength ; a ++ ) { ReferenceBinding inheritedInterface = itsInterfaces [ a ] ; if ( ( ! ( inheritedInterfaces . includes ( inheritedInterface ) ) ) && ( inheritedInterface . isValidBinding ( ) ) ) { if ( interfacesToCheck . includes ( inheritedInterface ) ) { TypeReference [ ] refs = this . type . scope . referenceContext . superInterfaces ; for ( int r = 0 , rl = refs . length ; r < rl ; r ++ ) { if ( ( refs [ r ] . resolvedType ) == inheritedInterface ) { problemReporter ( ) . redundantSuperInterface ( this . type , refs [ r ] , inheritedInterface , superType ) ; break ; } } } else { inheritedInterfaces . add ( inheritedInterface ) ; interfacesToVisit [ ( nextPosition ++ ) ] = inheritedInterface ; } } } } } } void checkInheritedMethods ( MethodBinding [ ] methods , int length ) { } boolean checkInheritedReturnTypes ( MethodBinding method , MethodBinding otherMethod ) { } void checkMethods ( ) { } void checkPackagePrivateAbstractMethod ( MethodBinding abstractMethod ) { } void computeInheritedMethods ( ) { } void computeInheritedMethods ( ReferenceBinding superclass , ReferenceBinding [ ] superInterfaces ) { } void computeMethods ( ) { } MethodBinding computeSubstituteMethod ( MethodBinding inheritedMethod , MethodBinding currentMethod ) { } boolean couldMethodOverride ( MethodBinding method , MethodBinding inheritedMethod ) { } public boolean doesMethodOverride ( MethodBinding method , MethodBinding inheritedMethod ) { } SimpleSet findSuperinterfaceCollisions ( ReferenceBinding superclass , ReferenceBinding [ ] superInterfaces ) { } MethodBinding findBestInheritedAbstractMethod ( MethodBinding [ ] methods , int length ) { }

Fix:
problemReporter ( ) . redundantSuperInterface ( this . type , refs [ j ] , superInterfaces [ j ] , toCheck ) ;