@Override public boolean isReferenceTo(PsiElement element) { return GoUtil.couldBeReferenceTo(element, getElement()) && getElement().getManager().areElementsEquivalent(resolve(), element); } };
/** * @param aClass a class to check. * @param baseClass supposed base class. * @param checkDeep true to check deeper than aClass.super (see {@linkplain PsiClass#isInheritor(com.intellij.psi.PsiClass, boolean)}). * @return true if aClass is the baseClass or baseClass inheritor */ public static boolean isInheritorOrSelf(@Nullable PsiClass aClass, @Nullable PsiClass baseClass, boolean checkDeep) { if (aClass == null || baseClass == null) return false; PsiManager manager = aClass.getManager(); return manager.areElementsEquivalent(baseClass, aClass) || aClass.isInheritor(baseClass, checkDeep); }
@Override public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { super.visitReferenceElement(reference); if (psiManager.areElementsEquivalent(reference.resolve(), member)) { result[0] = true; stopWalking(); } } });
public boolean isReferenceTo(PsiElement element) { return PsiManager.getInstance(element.getProject()).areElementsEquivalent(element, resolve()); }
@Nullable public static PsiSubstitutor getClassSubstitutor(@NotNull PsiClass superClassCandidate, @NotNull PsiClass derivedClassCandidate, @NotNull PsiSubstitutor derivedSubstitutor) { if (superClassCandidate.getManager().areElementsEquivalent(superClassCandidate, derivedClassCandidate)) { PsiTypeParameter[] baseParams = superClassCandidate.getTypeParameters(); PsiTypeParameter[] derivedParams = derivedClassCandidate.getTypeParameters(); if (baseParams.length > 0 && derivedParams.length == 0) { return JavaPsiFacade.getInstance(superClassCandidate.getProject()).getElementFactory().createRawSubstitutor(superClassCandidate); } return derivedSubstitutor; } return getMaybeSuperClassSubstitutor(superClassCandidate, derivedClassCandidate, derivedSubstitutor, null); }
private static boolean areSameParameterTypes(@NotNull PsiClassType type1, @NotNull PsiClassType type2) { PsiClassType.ClassResolveResult resolveResult1 = type1.resolveGenerics(); PsiClassType.ClassResolveResult resolveResult2 = type2.resolveGenerics(); final PsiClass aClass = resolveResult1.getElement(); final PsiClass bClass = resolveResult2.getElement(); return aClass != null && bClass != null && aClass.getManager().areElementsEquivalent(aClass, bClass) && areSameArgumentTypes(aClass, resolveResult1.getSubstitutor(), resolveResult2.getSubstitutor(), 1); }
PsiSubstitutor leftSubstitutor = leftResult.getSubstitutor(); if (!leftClass.getManager().areElementsEquivalent(leftClass, rightClass)) { rightSubstitutor = superSubstitutor; rightClass = leftClass;
private static boolean checkSuperTypesWithDifferentTypeArguments(@NotNull PsiClassType.ClassResolveResult baseResult, @NotNull PsiClass derived, @NotNull PsiManager manager, @NotNull PsiSubstitutor derivedSubstitutor, Set<PsiClass> visited, @NotNull LanguageLevel languageLevel) { if (visited != null && visited.contains(derived)) return true; if (languageLevel.compareTo(LanguageLevel.JDK_1_5) < 0) return true; PsiClass base = baseResult.getElement(); PsiClass[] supers = derived.getSupers(); if (manager.areElementsEquivalent(base, derived)) { derivedSubstitutor = getSuperClassSubstitutor(derived, derived, derivedSubstitutor); return areSameArgumentTypes(derived, baseResult.getSubstitutor(), derivedSubstitutor, 1); } else { PsiSubstitutor baseSubstitutor = getMaybeSuperClassSubstitutor(derived, base, baseResult.getSubstitutor(), null); if (baseSubstitutor != null) { derivedSubstitutor = getSuperClassSubstitutor(derived, derived, derivedSubstitutor); if (!areSameArgumentTypes(derived, baseSubstitutor, derivedSubstitutor)) return false; } } if (visited == null) visited = new THashSet<PsiClass>(); visited.add(derived); for (PsiClass aSuper : supers) { PsiSubstitutor s = getSuperClassSubstitutor(aSuper, derived, derivedSubstitutor); if (!checkSuperTypesWithDifferentTypeArguments(baseResult, aSuper, manager, s, visited, languageLevel)) return false; } return true; }
@Override public boolean isReferenceTo(PsiElement element) { if (resolveHandler != null) { final ResolveResult[] results = multiResolve(false); for (ResolveResult result : results) { if (getElement().getManager().areElementsEquivalent(result.getElement(), element)) { return true; } } return false; } return (predicate == null || predicate.test(element)) && resolve() == element; }
public static boolean hasEnclosingInstanceInScope(PsiClass aClass, PsiElement scope, final boolean isSuperClassAccepted, boolean isTypeParamsAccepted) { PsiManager manager = aClass.getManager(); PsiElement place = scope; while (place != null && place != aClass && !(place instanceof PsiFile)) { if (place instanceof PsiClass) { if (isSuperClassAccepted) { if (isInheritorOrSelf((PsiClass)place, aClass, true)) return true; } else { if (manager.areElementsEquivalent(place, aClass)) return true; } if (isTypeParamsAccepted && place instanceof PsiTypeParameter) { return true; } } if (place instanceof PsiModifierListOwner) { final PsiModifierList modifierList = ((PsiModifierListOwner)place).getModifierList(); if (modifierList != null && modifierList.hasModifierProperty(PsiModifier.STATIC)) { return false; } } place = place.getParent(); } return place == aClass; } }
public boolean equals(Object obj) { if (this == obj) return true; if (!(obj instanceof PsiClassType)) { return obj instanceof PsiCapturedWildcardType && ((PsiCapturedWildcardType)obj).getLowerBound().equalsToText(CommonClassNames.JAVA_LANG_OBJECT) && equalsToText(CommonClassNames.JAVA_LANG_OBJECT); } PsiClassType otherClassType = (PsiClassType)obj; String className = getClassName(); String otherClassName = otherClassType.getClassName(); if (!Comparing.equal(className, otherClassName)) return false; if (getParameterCount() != otherClassType.getParameterCount()) return false; final ClassResolveResult result = resolveGenerics(); final ClassResolveResult otherResult = otherClassType.resolveGenerics(); if (result == otherResult) return true; final PsiClass aClass = result.getElement(); final PsiClass otherClass = otherResult.getElement(); if (aClass == null || otherClass == null) { return aClass == otherClass; } return aClass.getManager().areElementsEquivalent(aClass, otherClass) && (PsiUtil.isRawSubstitutor(aClass, result.getSubstitutor()) || PsiUtil.equalOnEquivalentClasses(this, aClass, otherClassType, otherClass)); }
if (manager.areElementsEquivalent(fromClass, toClass)) { return areSameParameterTypes(fromClassType, toClassType);