Java PsiUtil.canBeOverriden方法代码示例

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
private static boolean canCallMethodsInConstructors(PsiClass aClass, boolean virtual) {
  for (PsiMethod constructor : aClass.getConstructors()) {
    if (!constructor.getLanguage().isKindOf(JavaLanguage.INSTANCE)) return true;

    PsiCodeBlock body = constructor.getBody();
    if (body == null) continue;

    for (PsiMethodCallExpression call : SyntaxTraverser.psiTraverser().withRoot(body).filter(PsiMethodCallExpression.class)) {
      PsiReferenceExpression methodExpression = call.getMethodExpression();
      if (methodExpression instanceof PsiThisExpression || methodExpression instanceof PsiSuperExpression) continue;
      if (!virtual) return true;
      
      PsiMethod target = call.resolveMethod();
      if (target != null && PsiUtil.canBeOverriden(target)) return true;
    }
  }

  return false;
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Override
public boolean ignoreInference(@NotNull PsiModifierListOwner owner, @Nullable String annotationFQN) {
  if (owner instanceof PsiMethod && PsiUtil.canBeOverriden((PsiMethod)owner)) {
    return true;
  }
  if (ORG_JETBRAINS_ANNOTATIONS_CONTRACT.equals(annotationFQN) && HardcodedContracts.hasHardcodedContracts(owner)) {
    return true;
  }
  if (AnnotationUtil.NOT_NULL.equals(annotationFQN) && owner instanceof PsiParameter && owner.getParent() != null) {
    if (AnnotationUtil.isAnnotated(owner, NullableNotNullManager.getInstance(owner.getProject()).getNullables(), false, false)) {
      return true;
    }
    if (HardcodedContracts.hasHardcodedContracts(owner)) {
      return true;
    }
  }
  return false;
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Override
@NotNull
public PsiElement[] getPrimaryElements() {
  final PsiElement element = getPsiElement();
  if (element instanceof PsiParameter) {
    final PsiParameter parameter = (PsiParameter)element;
    final PsiElement scope = parameter.getDeclarationScope();
    if (scope instanceof PsiMethod) {
      final PsiMethod method = (PsiMethod)scope;
      if (PsiUtil.canBeOverriden(method)) {
        final PsiClass aClass = method.getContainingClass();
        LOG.assertTrue(aClass != null); //Otherwise can not be overriden

        boolean hasOverridden = OverridingMethodsSearch.search(method).findFirst() != null;
        if (hasOverridden && askWhetherShouldSearchForParameterInOverridingMethods(element, parameter)) {
          return getParameterElementsToSearch(parameter, method);
        }
      }
    }
  }
  return myElementsToSearch.length == 0 ? new PsiElement[]{element} : myElementsToSearch;
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Override
public void collectSlowLineMarkers(@NotNull final List<PsiElement> elements, @NotNull final Collection<LineMarkerInfo> result) {
  ApplicationManager.getApplication().assertReadAccessAllowed();
  Map<PsiClass, PsiClass> subClassCache = FindSuperElementsHelper.createSubClassCache();

  Collection<PsiMethod> methods = new THashSet<PsiMethod>();
  //noinspection ForLoopReplaceableByForEach
  for (int i = 0; i < elements.size(); i++) {
    PsiElement element = elements.get(i);
    ProgressManager.checkCanceled();
    if (!(element instanceof PsiIdentifier)) continue;
    PsiElement parent = element.getParent();
    if (parent instanceof PsiMethod) {
      final PsiMethod method = (PsiMethod)parent;
      if (PsiUtil.canBeOverriden(method)) {
        methods.add(method);
      }
    }
    else if (parent instanceof PsiClass && !(parent instanceof PsiTypeParameter)) {
      collectInheritingClasses((PsiClass)parent, result, subClassCache);
    }
  }
  if (!methods.isEmpty()) {
    collectOverridingMethods(methods, result);
    collectSiblingInheritedMethods(methods, result, subClassCache);
  }
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Override
public void visitMethodCallExpression(@NotNull PsiMethodCallExpression expression) {
  super.visitMethodCallExpression(expression);
  if (!MethodCallUtils.isCallDuringObjectConstruction(expression)) {
    return;
  }
  final PsiReferenceExpression methodExpression = expression.getMethodExpression();
  final PsiExpression qualifier = methodExpression.getQualifierExpression();
  if (qualifier != null) {
    if (!(qualifier instanceof PsiThisExpression || qualifier instanceof PsiSuperExpression)) {
      return;
    }
  }
  final PsiClass containingClass = PsiTreeUtil.getParentOfType(expression, PsiClass.class);
  if (containingClass == null || containingClass.hasModifierProperty(PsiModifier.FINAL)) {
    return;
  }
  final PsiMethod calledMethod = expression.resolveMethod();
  if (calledMethod == null || !PsiUtil.canBeOverriden(calledMethod)) {
    return;
  }
  final PsiClass calledMethodClass = calledMethod.getContainingClass();
  if (!InheritanceUtil.isInheritorOrSelf(containingClass, calledMethodClass, true)) {
    return;
  }
  if (!MethodUtils.isOverriddenInHierarchy(calledMethod, containingClass)) {
    return;
  }
  if (CloneUtils.isClone(calledMethod)) {
    final PsiMethod containingMethod = PsiTreeUtil.getParentOfType(expression, PsiMethod.class);
    if (CloneUtils.isClone(containingMethod)) {
      return;
    }
  }
  registerMethodCallError(expression);
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Override
public void visitMethodCallExpression(@NotNull PsiMethodCallExpression expression) {
  super.visitMethodCallExpression(expression);
  if (!MethodCallUtils.isCallDuringObjectConstruction(expression)) {
    return;
  }
  final PsiReferenceExpression methodExpression = expression.getMethodExpression();
  final PsiExpression qualifier = methodExpression.getQualifierExpression();
  if (qualifier != null) {
    if (!(qualifier instanceof PsiThisExpression || qualifier instanceof PsiSuperExpression)) {
      return;
    }
  }
  final PsiClass containingClass = PsiTreeUtil.getParentOfType(expression, PsiClass.class);
  if (containingClass == null || containingClass.hasModifierProperty(PsiModifier.FINAL)) {
    return;
  }
  final PsiMethod calledMethod = expression.resolveMethod();
  if (calledMethod == null || !PsiUtil.canBeOverriden(calledMethod) || calledMethod.hasModifierProperty(PsiModifier.PACKAGE_LOCAL)) {
    return;
  }
  final PsiClass calledMethodClass = calledMethod.getContainingClass();
  if (calledMethodClass == null || !calledMethodClass.equals(containingClass)) {
    return;
  }
  registerMethodCallError(expression, expression);
}