public static boolean areSignaturesEqualLightweight(
@NotNull MethodSignature sig1, @NotNull MethodSignature sig2) {
final boolean isConstructor1 = sig1.isConstructor();
final boolean isConstructor2 = sig2.isConstructor();
if (isConstructor1 != isConstructor2) return false;
if (!isConstructor1
|| !(sig1 instanceof HierarchicalMethodSignature
|| sig2 instanceof HierarchicalMethodSignature)) {
final String name1 = sig1.getName();
final String name2 = sig2.getName();
if (!name1.equals(name2)) return false;
}
final PsiType[] parameterTypes1 = sig1.getParameterTypes();
final PsiType[] parameterTypes2 = sig2.getParameterTypes();
if (parameterTypes1.length != parameterTypes2.length) return false;
// optimization: check for really different types in method parameters
for (int i = 0; i < parameterTypes1.length; i++) {
final PsiType type1 = parameterTypes1[i];
final PsiType type2 = parameterTypes2[i];
if (type1 instanceof PsiPrimitiveType != type2 instanceof PsiPrimitiveType) return false;
if (type1 instanceof PsiPrimitiveType && !type1.equals(type2)) return false;
}
return true;
}
@Nullable
private static PsiMethod doFindMethodInSuperClassBySignatureInDerived(
@NotNull PsiClass superClass,
@NotNull PsiSubstitutor superSubstitutor,
@NotNull MethodSignature signature,
final boolean checkDeep) {
final String name = signature.getName();
final PsiMethod[] methods = superClass.findMethodsByName(name, false);
for (final PsiMethod method : methods) {
if (isSubsignature(method.getSignature(superSubstitutor), signature)) {
return method;
}
}
if (checkDeep) {
final PsiClass clazz = superClass.getSuperClass();
if (clazz != null && clazz != superClass) {
PsiSubstitutor substitutor1 =
TypeConversionUtil.getSuperClassSubstitutor(clazz, superClass, superSubstitutor);
return doFindMethodInSuperClassBySignatureInDerived(clazz, substitutor1, signature, true);
}
}
return null;
}
@Nullable
public static PsiMethod findMethodBySignature(
@NotNull PsiClass aClass, @NotNull MethodSignature methodSignature, boolean checkBases) {
String name = methodSignature.isConstructor() ? aClass.getName() : methodSignature.getName();
List<Pair<PsiMethod, PsiSubstitutor>> pairs =
aClass.findMethodsAndTheirSubstitutorsByName(name, checkBases);
for (Pair<PsiMethod, PsiSubstitutor> pair : pairs) {
PsiMethod method = pair.first;
PsiSubstitutor substitutor = pair.second;
MethodSignature foundMethodSignature = method.getSignature(substitutor);
if (methodSignature.equals(foundMethodSignature)) return method;
}
return null;
}
@Override
public int computeHashCode(final MethodSignature signature) {
int result = signature.isConstructor() ? 0 : signature.getName().hashCode();
PsiType[] parameterTypes = signature.getParameterTypes();
result += 37 * parameterTypes.length;
PsiType firstParamType = parameterTypes.length == 0 ? null : parameterTypes[0];
if (firstParamType != null) {
firstParamType = TypeConversionUtil.erasure(firstParamType, signature.getSubstitutor());
assert firstParamType != null : parameterTypes[0];
result = 31 * result + firstParamType.hashCode();
}
return result;
}
