下面列出了怎么用com.intellij.psi.util.PsiUtil的API类实例代码及写法,或者点击链接到github查看源代码。
private void setPublicModifierToSourceTypeDeclaration() {
InheritanceTree tree = null;
if (typeCheckElimination.getExistingInheritanceTree() != null) {
tree = typeCheckElimination.getExistingInheritanceTree();
} else if (typeCheckElimination.getInheritanceTreeMatchingWithStaticTypes() != null) {
tree = typeCheckElimination.getInheritanceTreeMatchingWithStaticTypes();
}
String abstractClassName = null;
if (tree != null) {
DefaultMutableTreeNode root = tree.getRootNode();
abstractClassName = (String) root.getUserObject();
}
String sourcePackageName = PsiUtil.getPackageName(sourceTypeDeclaration);
if (sourcePackageName != null && abstractClassName != null && abstractClassName.contains(".")) {
String targetPackageName = abstractClassName.substring(0, abstractClassName.lastIndexOf("."));
if (!sourcePackageName.equals(targetPackageName)) {
PsiUtil.setModifierProperty(sourceTypeDeclaration, PsiModifier.PUBLIC, true);
}
}
}
@Override
public void navigate(MouseEvent mouseEvent, PsiElement psiElement) {
if (canNavigate(psiElement)) {
final Project project = psiElement.getProject();
final List<PsiElement> psiElements = findReferences(psiElement);
if (psiElements.size() == 1) {
FileEditorManager.getInstance(project).openFile(PsiUtil.getVirtualFile(psiElements.get(0)), true);
} else if (psiElements.size() > 1) {
NavigationUtil.getPsiElementPopup(psiElements.toArray(new PsiElement[0]), title).show(new RelativePoint(mouseEvent));
} else {
if (Objects.isNull(psiElements) || psiElements.size() <= 0) {
Messages.showErrorDialog("没有找到这个调用的方法,请检查!", "错误提示");
}
}
}
}
@Override
public boolean isMemberEnabled(MemberInfo member) {
final PsiClass currentSuperClass = getSuperClass();
if(currentSuperClass == null) return true;
if (myMemberInfoStorage.getDuplicatedMemberInfos(currentSuperClass).contains(member)) return false;
if (myMemberInfoStorage.getExtending(currentSuperClass).contains(member.getMember())) return false;
final boolean isInterface = currentSuperClass.isInterface();
if (!isInterface) return true;
PsiElement element = member.getMember();
if (element instanceof PsiClass && ((PsiClass) element).isInterface()) return true;
if (element instanceof PsiField) {
return ((PsiModifierListOwner) element).hasModifierProperty(PsiModifier.STATIC);
}
if (element instanceof PsiMethod) {
final PsiSubstitutor superSubstitutor = TypeConversionUtil
.getSuperClassSubstitutor(currentSuperClass, myClass, PsiSubstitutor.EMPTY);
final MethodSignature signature = ((PsiMethod) element).getSignature(superSubstitutor);
final PsiMethod superClassMethod = MethodSignatureUtil.findMethodBySignature(currentSuperClass, signature, false);
if (superClassMethod != null && !PsiUtil.isLanguageLevel8OrHigher(currentSuperClass)) return false;
return !((PsiModifierListOwner) element).hasModifierProperty(PsiModifier.STATIC) || PsiUtil.isLanguageLevel8OrHigher(currentSuperClass);
}
return true;
}
private PsiMethod generateCopyConstructor(final PsiClass targetClass, final PsiType builderType,
final Collection<PsiFieldMember> nonFinalFields,
final Set<InnerBuilderOption> options) {
final PsiMethod copyConstructor = psiElementFactory.createConstructor(builderType.getPresentableText());
PsiUtil.setModifierProperty(copyConstructor, PsiModifier.PUBLIC, true);
final PsiType targetClassType = psiElementFactory.createType(targetClass);
final PsiParameter constructorParameter = psiElementFactory.createParameter("copy", targetClassType);
final PsiModifierList parameterModifierList = constructorParameter.getModifierList();
if (parameterModifierList != null) {
if (options.contains(InnerBuilderOption.JSR305_ANNOTATIONS))
parameterModifierList.addAnnotation(JSR305_NONNULL);
if (options.contains(InnerBuilderOption.FINDBUGS_ANNOTATION))
parameterModifierList.addAnnotation(FINDBUGS_NONNULL);
}
copyConstructor.getParameterList().add(constructorParameter);
addCopyBody(nonFinalFields, copyConstructor, "this.");
return copyConstructor;
}
/**
* @param file psi file
* @param editor editor
* @return psiClass if class is static or top level. Otherwise returns {@code null}
*/
@Nullable
public static PsiClass getStaticOrTopLevelClass(PsiFile file, Editor editor) {
final int offset = editor.getCaretModel().getOffset();
final PsiElement element = file.findElementAt(offset);
if (element == null) {
return null;
}
PsiClass topLevelClass = PsiUtil.getTopLevelClass(element);
PsiClass psiClass = PsiTreeUtil.getParentOfType(element, PsiClass.class);
if (psiClass != null && (psiClass.hasModifierProperty(PsiModifier.STATIC) ||
psiClass.getManager().areElementsEquivalent(psiClass, topLevelClass)))
return psiClass;
else
return null;
}
public GodClassUserInputDialog(AbstractExtractClassRefactoring abstractRefactoring, AbstractRefactoringPanel godClassPanel) {
super(abstractRefactoring.getRefactoring().getSourceFile().getProject(), true);
this.abstractRefactoring = abstractRefactoring;
this.refactoring = abstractRefactoring.getRefactoring();
String packageName = PsiUtil.getPackageName(refactoring.getSourceClass());
parentPackage = JavaPsiFacade.getInstance(refactoring.getProject()).findPackage(packageName);
this.godClassPanel = godClassPanel;
initialiseControls();
setTitle(IntelliJDeodorantBundle.message("god.class.dialog.title"));
init();
}
public ReplaceTypeCodeWithStateStrategyDialog(ReplaceTypeCodeWithStateStrategy refactoring,
Runnable applyRefactoringCallback) {
super(refactoring.getProject(), true);
this.refactoring = refactoring;
String packageName = PsiUtil.getPackageName(refactoring.getSourceTypeDeclaration());
parentPackage = JavaPsiFacade.getInstance(refactoring.getProject()).findPackage(packageName);
this.applyRefactoringCallback = applyRefactoringCallback;
init();
setTitle(IntelliJDeodorantBundle.message("replace.type.code.with.state.strategy.name"));
setListeners();
}
void processThrowStatement(PsiThrowStatement throwStatement) {
PsiExpression expression = throwStatement.getException();
if (expression instanceof PsiNewExpression) {
PsiNewExpression newExpression = (PsiNewExpression) expression;
if (newExpression.getArrayDimensions().length == 0) {
PsiMethod constructorCall = newExpression.resolveConstructor();
if (constructorCall != null) {
addExceptionInThrowStatement(PsiUtil.getMemberQualifiedName(constructorCall));
}
}
}
}
private Set<PsiPrefixExpression> getMatchingPrefixAssignments(PsiVariable variable, List<PsiExpression> prefixExpressions) {
Set<PsiPrefixExpression> matchingPrefixAssignments = new LinkedHashSet<>();
for (PsiExpression expression : prefixExpressions) {
if (expression instanceof PsiPrefixExpression) {
PsiPrefixExpression prefixExpression = (PsiPrefixExpression) expression;
PsiExpression operand = prefixExpression.getOperand();
if (operand == null) continue;
PsiElement element = operand.getLastChild();
if (element != null && element.equals(variable) && PsiUtil.isIncrementDecrementOperation(operand)) {
matchingPrefixAssignments.add(prefixExpression);
}
}
}
return matchingPrefixAssignments;
}
public PsiClass resolveClassReference(@NotNull PsiReference reference) {
final PsiElement resolveElement = reference.resolve();
if (resolveElement instanceof PsiClass) {
return (PsiClass) resolveElement;
} else if (resolveElement instanceof PsiField) {
final PsiType psiType = PsiUtil.getTypeByPsiElement(resolveElement);
if (psiType != null) {
return ((PsiClassReferenceType) psiType).resolve();
}
}
return null;
}
@Override
public int getAccessLevel() {
HaxeNamedComponent namedComponent = null;
if (myElement instanceof HaxeNamedComponent) {
namedComponent = (HaxeNamedComponent)myElement;
}
else if (myElement.getParent() instanceof HaxeNamedComponent) {
namedComponent = (HaxeNamedComponent)myElement.getParent();
}
return namedComponent == null || !namedComponent.isPublic() ? PsiUtil.ACCESS_LEVEL_PROTECTED : PsiUtil.ACCESS_LEVEL_PUBLIC;
}
private void removeFromTargetClass() throws IncorrectOperationException {
for (MemberInfo memberInfo : myMemberInfos) {
final PsiElement member = memberInfo.getMember();
if (member instanceof PsiField) {
member.delete();
}
else if (member instanceof PsiMethod) {
if (memberInfo.isToAbstract()) {
final PsiMethod method = (PsiMethod)member;
if (method.hasModifierProperty(PsiModifier.PRIVATE)) {
PsiUtil.setModifierProperty(method, PsiModifier.PROTECTED, true);
}
RefactoringUtil.makeMethodAbstract(myClass, method);
myJavaDocPolicy.processOldJavaDoc(method.getDocComment());
}
else {
member.delete();
}
}
else if (member instanceof PsiClass) {
//if (Boolean.FALSE.equals(memberInfo.getOverrides())) {
//RefactoringUtil.removeFromReferenceList(myClass.getImplementsList(), (PsiClass)member);
//}
//else {
//}
member.delete();
}
}
}
@Override
public boolean isAbstractEnabled(MemberInfo member) {
PsiClass currentSuperClass = getSuperClass();
if (currentSuperClass == null || !currentSuperClass.isInterface()) return true;
if (PsiUtil.isLanguageLevel8OrHigher(currentSuperClass)) {
return true;
}
return false;
}
@Override
public void setCorrectVisibility(MemberInfo info) {
PsiModifierListOwner modifierListOwner = info.getMember();
if (myIsTargetInterface) {
PsiUtil.setModifierProperty(modifierListOwner, PsiModifier.PUBLIC, true);
}
else if (modifierListOwner.hasModifierProperty(PsiModifier.PRIVATE)) {
if (info.isToAbstract() || willBeUsedInSubclass(modifierListOwner, myTargetSuperClass, mySourceClass)) {
PsiUtil.setModifierProperty(modifierListOwner, PsiModifier.PROTECTED, true);
}
if (modifierListOwner instanceof PsiClass) {
modifierListOwner.accept(new JavaRecursiveElementWalkingVisitor() {
@Override
public void visitMethod(PsiMethod method) {
check(method);
}
@Override
public void visitField(PsiField field) {
check(field);
}
@Override
public void visitClass(PsiClass aClass) {
check(aClass);
super.visitClass(aClass);
}
private void check(PsiMember member) {
if (member.hasModifierProperty(PsiModifier.PRIVATE)) {
if (willBeUsedInSubclass(member, myTargetSuperClass, mySourceClass)) {
PsiUtil.setModifierProperty(member, PsiModifier.PROTECTED, true);
}
}
}
});
}
}
}
private void doMoveField(PsiSubstitutor substitutor, MemberInfo info) {
PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(myProject);
PsiField field = (PsiField)info.getMember();
field.normalizeDeclaration();
RefactoringUtil.replaceMovedMemberTypeParameters(field, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory);
fixReferencesToStatic(field);
if (myIsTargetInterface) {
PsiUtil.setModifierProperty(field, PsiModifier.PUBLIC, true);
}
final PsiMember movedElement = (PsiMember)myTargetSuperClass.addBefore(convertFieldToLanguage(field, myTargetSuperClass.getLanguage()), myTargetSuperClass.getRBrace());
myMembersAfterMove.add(movedElement);
field.delete();
}
private void addMethodsOfType(PsiType psiType, Collection<Pair<PsiMethod, PsiSubstitutor>> allMethods) {
final PsiClassType.ClassResolveResult resolveResult = PsiUtil.resolveGenericsClassInType(psiType);
final PsiClass psiClass = resolveResult.getElement();
if (null != psiClass) {
collectAllMethods(allMethods, psiClass, resolveResult.getSubstitutor());
}
}
@NotNull
public static PsiAnnotation createAnnotationWithAccessLevel(@NotNull Class<? extends Annotation> annotationClass, @NotNull PsiModifierListOwner psiModifierListOwner) {
String value = "";
final PsiModifierList modifierList = psiModifierListOwner.getModifierList();
if (null != modifierList) {
final int accessLevelCode = PsiUtil.getAccessLevel(modifierList);
final AccessLevel accessLevel = ACCESS_LEVEL_MAP.get(accessLevelCode);
if (null != accessLevel && !AccessLevel.PUBLIC.equals(accessLevel)) {
value = AccessLevel.class.getName() + "." + accessLevel;
}
}
return PsiAnnotationUtil.createPsiAnnotation(psiModifierListOwner, annotationClass, value);
}
private static PsiType substituteTypeParameter(@NotNull PsiType psiType, String superClass, int paramIndex) {
PsiType oneElementType = PsiUtil.substituteTypeParameter(psiType, superClass, paramIndex, true);
if (oneElementType instanceof PsiWildcardType) {
oneElementType = ((PsiWildcardType) oneElementType).getBound();
}
return oneElementType;
}
private boolean isNotAnnotatedWithOrSameAccessLevelAs(PsiClass psiClass, PsiMethod firstPropertyMethod, Class<? extends Annotation> annotationClass) {
final PsiAnnotation presentAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiClass, annotationClass);
if (null != presentAnnotation) {
final String presentAccessModifier = LombokProcessorUtil.getMethodModifier(presentAnnotation);
final String currentAccessModifier = PsiUtil.getAccessModifier(PsiUtil.getAccessLevel(firstPropertyMethod.getModifierList()));
return (presentAccessModifier == null && currentAccessModifier == null) ||
(presentAccessModifier != null && presentAccessModifier.equals(currentAccessModifier));
}
return true;
}
private boolean haveAllMethodsSameAccessLevel(Collection<PsiMethod> psiMethods) {
final Set<Integer> accessLevelSet = new HashSet<>();
for (PsiMethod psiMethod : psiMethods) {
accessLevelSet.add(PsiUtil.getAccessLevel(psiMethod.getModifierList()));
}
return accessLevelSet.size() <= 1;
}
private PsiMethod generateBuilderConstructor(final PsiClass builderClass,
final Collection<PsiFieldMember> finalFields,
final Set<InnerBuilderOption> options) {
final PsiMethod builderConstructor = psiElementFactory.createConstructor(builderClass.getName());
if (options.contains(InnerBuilderOption.NEW_BUILDER_METHOD)) {
PsiUtil.setModifierProperty(builderConstructor, PsiModifier.PRIVATE, true);
} else {
PsiUtil.setModifierProperty(builderConstructor, PsiModifier.PUBLIC, true);
}
final PsiCodeBlock builderConstructorBody = builderConstructor.getBody();
if (builderConstructorBody != null) {
for (final PsiFieldMember member : finalFields) {
final PsiField field = member.getElement();
final PsiType fieldType = field.getType();
final String fieldName = field.getName();
final PsiParameter parameter = psiElementFactory.createParameter(fieldName, fieldType);
final PsiModifierList parameterModifierList = parameter.getModifierList();
final boolean useJsr305 = options.contains(InnerBuilderOption.JSR305_ANNOTATIONS);
final boolean useFindbugs = options.contains(InnerBuilderOption.FINDBUGS_ANNOTATION);
if (!InnerBuilderUtils.isPrimitive(field) && parameterModifierList != null) {
if (useJsr305) parameterModifierList.addAnnotation(JSR305_NONNULL);
if (useFindbugs) parameterModifierList.addAnnotation(FINDBUGS_NONNULL);
}
builderConstructor.getParameterList().add(parameter);
final PsiStatement assignStatement = psiElementFactory.createStatementFromText(String.format(
"this.%1$s = %1$s;", fieldName), builderConstructor);
builderConstructorBody.add(assignStatement);
}
}
return builderConstructor;
}
private PsiMethod generateNewBuilderMethod(final PsiType builderType, final Collection<PsiFieldMember> finalFields,
final Set<InnerBuilderOption> options) {
final PsiMethod newBuilderMethod = psiElementFactory.createMethod("newBuilder", builderType);
PsiUtil.setModifierProperty(newBuilderMethod, PsiModifier.STATIC, true);
PsiUtil.setModifierProperty(newBuilderMethod, PsiModifier.PUBLIC, true);
final StringBuilder fieldList = new StringBuilder();
if (!finalFields.isEmpty()) {
for (final PsiFieldMember member : finalFields) {
final PsiField field = member.getElement();
final PsiType fieldType = field.getType();
final String fieldName = field.getName();
final PsiParameter parameter = psiElementFactory.createParameter(fieldName, fieldType);
final PsiModifierList parameterModifierList = parameter.getModifierList();
if (parameterModifierList != null) {
if (!InnerBuilderUtils.isPrimitive(field)) {
if (options.contains(InnerBuilderOption.JSR305_ANNOTATIONS))
parameterModifierList.addAnnotation(JSR305_NONNULL);
if (options.contains(InnerBuilderOption.FINDBUGS_ANNOTATION))
parameterModifierList.addAnnotation(FINDBUGS_NONNULL);
}
}
newBuilderMethod.getParameterList().add(parameter);
if (fieldList.length() > 0) {
fieldList.append(", ");
}
fieldList.append(fieldName);
}
}
final PsiCodeBlock newBuilderMethodBody = newBuilderMethod.getBody();
if (newBuilderMethodBody != null) {
final PsiStatement newStatement = psiElementFactory.createStatementFromText(String.format(
"return new %s(%s);", builderType.getPresentableText(), fieldList.toString()),
newBuilderMethod);
newBuilderMethodBody.add(newStatement);
}
return newBuilderMethod;
}
@NotNull
private PsiClass createBuilderClass(final PsiClass targetClass) {
final PsiClass builderClass = (PsiClass) targetClass.add(psiElementFactory.createClass(BUILDER_CLASS_NAME));
PsiUtil.setModifierProperty(builderClass, PsiModifier.STATIC, true);
PsiUtil.setModifierProperty(builderClass, PsiModifier.FINAL, true);
setBuilderComment(builderClass, targetClass);
setBuilderAnnotation(builderClass);
return builderClass;
}
static String getPackageName(final PsiField configField) {
return PsiUtil.getPackageName(configField.getContainingClass());
}
private void setPublicModifierToSourceField(PsiField variableBinding) {
PsiUtil.setModifierProperty(variableBinding, PsiModifier.PUBLIC, true);
}
protected void setPublicModifierToAccessedMethods() {
for (PsiMethod methodDeclaration : typeCheckElimination.getAccessedMethods()) {
PsiUtil.setModifierProperty(methodDeclaration, PsiModifier.PUBLIC, true);
}
}
private PsiMethod createPolymorphicMethodHeader() {
String methodName = typeCheckElimination.getAbstractMethodName();
PsiType returnType = PsiType.VOID;
if (returnedVariable != null) {
returnType = returnedVariable.getType();
} else if (typeCheckElimination.typeCheckCodeFragmentContainsReturnStatement()) { // TODO: looks really suspicious
returnType = typeCheckElimination.getTypeCheckMethodReturnType();
}
PsiMethod createdMethod = elementFactory.createMethod(methodName, returnType);
PsiUtil.setModifierProperty(createdMethod, PsiModifier.PUBLIC, true);
PsiParameterList abstractMethodParameters = createdMethod.getParameterList();
if (returnedVariable != null && !typeCheckElimination.returnedVariableDeclaredAndReturnedInBranches()) {
abstractMethodParameters.add(elementFactory.createParameter(returnedVariable.getName(), returnedVariable.getType()));
}
for (PsiParameter accessedParameter : typeCheckElimination.getAccessedParameters()) {
if (!accessedParameter.equals(returnedVariable) && !accessedParameter.equals(typeVariable)) {
abstractMethodParameters.add(elementFactory.createParameter(accessedParameter.getName(), accessedParameter.getType()));
}
}
for (PsiVariable fragment : typeCheckElimination.getAccessedLocalVariables()) {
if (!fragment.equals(returnedVariable) && !fragment.equals(typeVariable)) {
abstractMethodParameters.add(elementFactory.createParameter(fragment.getName(), fragment.getType()));
}
}
if (sourceTypeRequiredForExtraction()) {
String parameterName = sourceTypeDeclaration.getName();
parameterName = parameterName.substring(0, 1).toLowerCase() + parameterName.substring(1);
PsiType parameterType = PsiTypesUtil.getClassType(sourceTypeDeclaration);
abstractMethodParameters.add(elementFactory.createParameter(parameterName, parameterType));
}
PsiReferenceList abstractMethodThrownExceptionsRewrite = createdMethod.getThrowsList();
for (PsiClassType typeBinding : thrownExceptions) {
abstractMethodThrownExceptionsRewrite.add(elementFactory.createReferenceElementByType(typeBinding));
}
return createdMethod;
}
/**
* Is the element from Java language
*/
public boolean isJavaLanguage(PsiElement element) {
return element != null && PsiUtil.getNotAnyLanguage(element.getNode()).is(JavaLanguage.INSTANCE);
}
/**
* Is the element from XML language
*/
public boolean isXmlLanguage(PsiElement element) {
return element != null && PsiUtil.getNotAnyLanguage(element.getNode()).is(XMLLanguage.INSTANCE);
}
@Override
public boolean process(@NotNull PsiReference reference, @NotNull JavaCallHierarchyData jchdata) {
if (!(jchdata instanceof CallData)) {
String msg = "Internal error, unexpected call data type passed in.";
LOG.error(msg);
throw new UnsupportedOperationException(msg);
}
CallData data = (CallData)jchdata;
PsiClass originalClass = data.getOriginalClass();
PsiMethod method = data.getMethod();
Set<PsiMethod> methodsToFind = data.getMethodsToFind();
PsiMethod methodToFind = data.getMethodToFind();
PsiClassType originalType = data.getOriginalType();
Map<PsiMember, NodeDescriptor> methodToDescriptorMap = data.getResultMap();
Project myProject = data.getProject();
HaxeHierarchyTimeoutHandler timeoutHandler = data.getTimeoutHandler();
// All done, if we time out.
if (timeoutHandler.checkAndCancelIfNecessary()) {
return false;
}
if (reference instanceof HaxeReferenceExpression) {
final PsiElement qualifierElement = ((HaxeReferenceExpression)reference).getQualifier();
final HaxeReferenceExpression qualifier = (HaxeReferenceExpression) qualifierElement;
if (qualifier instanceof HaxeSuperExpression) { // filter super.foo() call inside foo() and similar cases (bug 8411)
final PsiClass superClass = PsiUtil.resolveClassInType(qualifier.getPsiType());
if (superClass == null || originalClass.isInheritor(superClass, true)) {
return true;
}
}
if (qualifier != null && !methodToFind.hasModifierProperty(PsiModifier.STATIC)) {
final PsiType qualifierType = qualifier.getPsiType();
if (qualifierType instanceof PsiClassType &&
!TypeConversionUtil.isAssignable(qualifierType, originalType) &&
methodToFind != method) {
final PsiClass psiClass = ((PsiClassType)qualifierType).resolve();
if (psiClass != null) {
final PsiMethod callee = psiClass.findMethodBySignature(methodToFind, true);
if (callee != null && !methodsToFind.contains(callee)) {
// skip sibling methods
return true;
}
}
}
}
}
else {
if (!(reference instanceof PsiElement)) {
return true;
}
final PsiElement parent = ((PsiElement)reference).getParent();
// If the parent is a 'new x' expression, but the reference isn't the primary
// expression, then keep looking.
if (parent instanceof HaxeNewExpression) {
if (((HaxeNewExpression)parent).getType().getReferenceExpression() != reference) {
return true;
}
}
// If the reference isn't the primary expression of an anonymous class, then keep looking?
else if (parent instanceof PsiAnonymousClass) {
// XXX: This appears to be an optimization, knowing that an anonymous class can't be
// referenced from outside of itself, there's no need to load the class by
// calling for the base reference (the first child of the class). The haxe
// PSI doesn't appear to be built in that fashion any way...
// if (((PsiAnonymousClass)parent).getBaseClassReference() != reference) {
// return true;
// }
// let it be processed.
}
else {
return true;
}
}
final PsiElement element = reference.getElement();
final PsiMember key = CallHierarchyNodeDescriptor.getEnclosingElement(element);
synchronized (methodToDescriptorMap) {
CallHierarchyNodeDescriptor d = (CallHierarchyNodeDescriptor)methodToDescriptorMap.get(key);
if (d == null) {
d = new CallHierarchyNodeDescriptor(myProject, (CallHierarchyNodeDescriptor)data.getNodeDescriptor(), element, false, true);
methodToDescriptorMap.put(key, d);
}
else if (!d.hasReference(reference)) {
d.incrementUsageCount();
}
d.addReference(reference);
}
return false;
}