@NotNull
private static List<PsiMethod> findMethodsBySignature(
@NotNull PsiClass aClass,
@NotNull PsiMethod patternMethod,
boolean checkBases,
boolean stopOnFirst) {
final PsiMethod[] methodsByName = aClass.findMethodsByName(patternMethod.getName(), checkBases);
if (methodsByName.length == 0) return Collections.emptyList();
final List<PsiMethod> methods = new SmartList<PsiMethod>();
final MethodSignature patternSignature = patternMethod.getSignature(PsiSubstitutor.EMPTY);
for (final PsiMethod method : methodsByName) {
final PsiClass superClass = method.getContainingClass();
final PsiSubstitutor substitutor;
if (checkBases && !aClass.equals(superClass)) {
substitutor =
TypeConversionUtil.getSuperClassSubstitutor(superClass, aClass, PsiSubstitutor.EMPTY);
} else {
substitutor = PsiSubstitutor.EMPTY;
}
final MethodSignature signature = method.getSignature(substitutor);
if (signature.equals(patternSignature)) {
methods.add(method);
if (stopOnFirst) {
break;
}
}
}
return methods;
}
@Nullable
public static PsiMethod findMethodBySignature(
GrTypeDefinition grType, PsiMethod patternMethod, boolean checkBases) {
final MethodSignature patternSignature = patternMethod.getSignature(PsiSubstitutor.EMPTY);
for (PsiMethod method : findMethodsByName(grType, patternMethod.getName(), checkBases, false)) {
MethodSignature signature = getSignatureForInheritor(method, grType);
if (patternSignature.equals(signature)) return method;
}
return null;
}
public static PsiType[] getErasedParameterTypes(MethodSignature signature) {
PsiType[] parameterTypes = signature.getParameterTypes();
if (parameterTypes.length == 0) return PsiType.EMPTY_ARRAY;
PsiSubstitutor substitutor = signature.getSubstitutor();
PsiType[] erasedTypes = new PsiType[parameterTypes.length];
for (int i = 0; i < parameterTypes.length; i++) {
erasedTypes[i] =
TypeConversionUtil.erasure(substitutor.substitute(parameterTypes[i]), substitutor);
}
return erasedTypes;
}
@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;
}
private static PsiMethod[] findMethodsBySignature(
GrTypeDefinition grType,
PsiMethod patternMethod,
boolean checkBases,
boolean includeSynthetic) {
ArrayList<PsiMethod> result = new ArrayList<PsiMethod>();
final MethodSignature patternSignature = patternMethod.getSignature(PsiSubstitutor.EMPTY);
for (PsiMethod method :
findMethodsByName(grType, patternMethod.getName(), checkBases, includeSynthetic)) {
MethodSignature signature = getSignatureForInheritor(method, grType);
if (patternSignature.equals(signature)) {
result.add(method);
}
}
return result.toArray(new PsiMethod[result.size()]);
}
@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;
}
public static boolean isSubsignature(
MethodSignature superSignature, MethodSignature subSignature) {
if (subSignature == superSignature) return true;
if (!areSignaturesEqualLightweight(superSignature, subSignature)) return false;
PsiSubstitutor unifyingSubstitutor =
getSuperMethodSignatureSubstitutor(subSignature, superSignature);
if (checkSignaturesEqualInner(superSignature, subSignature, unifyingSubstitutor)) return true;
if (subSignature.getTypeParameters().length > 0) return false;
final PsiType[] subParameterTypes = subSignature.getParameterTypes();
final PsiType[] superParameterTypes = superSignature.getParameterTypes();
for (int i = 0; i < subParameterTypes.length; i++) {
PsiType type1 = subParameterTypes[i];
PsiType type2 = TypeConversionUtil.erasure(superParameterTypes[i]);
if (!Comparing.equal(type1, type2)) return false;
}
return true;
}
private static boolean checkSignaturesEqualInner(
@NotNull MethodSignature subSignature,
@NotNull MethodSignature superSignature,
final PsiSubstitutor unifyingSubstitutor) {
if (unifyingSubstitutor == null) return false;
if (!areErasedParametersEqual(subSignature, superSignature)) return false;
final PsiType[] subParameterTypes = subSignature.getParameterTypes();
final PsiType[] superParameterTypes = superSignature.getParameterTypes();
for (int i = 0; i < subParameterTypes.length; i++) {
final PsiType type1 = unifyingSubstitutor.substitute(subParameterTypes[i]);
final PsiType type2 = unifyingSubstitutor.substitute(superParameterTypes[i]);
if (!Comparing.equal(type1, type2)) {
return false;
}
}
return true;
}
@Nullable
private static PsiSubstitutor getSuperMethodSignatureSubstitutorImpl(
@NotNull MethodSignature methodSignature, @NotNull MethodSignature superSignature) {
// normalize generic method declarations: correlate type parameters
// todo: correlate type params by name?
PsiTypeParameter[] methodTypeParameters = methodSignature.getTypeParameters();
PsiTypeParameter[] superTypeParameters = superSignature.getTypeParameters();
// both methods are parameterized and number of parameters mismatch
if (methodTypeParameters.length != superTypeParameters.length) return null;
PsiSubstitutor result = superSignature.getSubstitutor();
for (int i = 0; i < methodTypeParameters.length; i++) {
PsiTypeParameter methodTypeParameter = methodTypeParameters[i];
PsiElementFactory factory =
JavaPsiFacade.getInstance(methodTypeParameter.getProject()).getElementFactory();
result = result.put(superTypeParameters[i], factory.createType(methodTypeParameter));
}
return result;
}
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;
}
/**
* @param methodSignature method signature
* @param superMethodSignature super method signature
* @return null if signatures do not match
*/
@Nullable
public static PsiSubstitutor getSuperMethodSignatureSubstitutor(
@NotNull MethodSignature methodSignature, @NotNull MethodSignature superMethodSignature) {
PsiSubstitutor result =
getSuperMethodSignatureSubstitutorImpl(methodSignature, superMethodSignature);
if (result == null) return null;
PsiTypeParameter[] methodTypeParameters = methodSignature.getTypeParameters();
PsiTypeParameter[] superTypeParameters = superMethodSignature.getTypeParameters();
PsiSubstitutor methodSubstitutor = methodSignature.getSubstitutor();
// check bounds
for (int i = 0; i < methodTypeParameters.length; i++) {
PsiTypeParameter methodTypeParameter = methodTypeParameters[i];
PsiTypeParameter superTypeParameter = superTypeParameters[i];
final Set<PsiType> methodSupers = new HashSet<PsiType>();
for (PsiClassType methodSuper : methodTypeParameter.getSuperTypes()) {
methodSupers.add(methodSubstitutor.substitute(methodSuper));
}
final Set<PsiType> superSupers = new HashSet<PsiType>();
for (PsiClassType superSuper : superTypeParameter.getSuperTypes()) {
superSupers.add(
methodSubstitutor.substitute(
PsiUtil.captureToplevelWildcards(
result.substitute(superSuper), methodTypeParameter)));
}
methodSupers.remove(
PsiType.getJavaLangObject(
methodTypeParameter.getManager(), methodTypeParameter.getResolveScope()));
superSupers.remove(
PsiType.getJavaLangObject(
superTypeParameter.getManager(), superTypeParameter.getResolveScope()));
if (!methodSupers.equals(superSupers)) return null;
}
return result;
}
@Override
public int computeHashCode(final MethodSignature signature) {
return signature.hashCode();
}