Java PsiMethod.getProject方法代码示例

import com.intellij.psi.PsiMethod; //导入方法依赖的package包/类
public static PsiMethod checkSuperMethod(@NotNull PsiMethod method, @NotNull String actionString) {
  PsiClass aClass = method.getContainingClass();
  if (aClass == null) return method;

  PsiMethod superMethod = method.findDeepestSuperMethod();
  if (superMethod == null) return method;

  if (ApplicationManager.getApplication().isUnitTestMode()) return superMethod;

  PsiClass containingClass = superMethod.getContainingClass();

  SuperMethodWarningDialog dialog =
      new SuperMethodWarningDialog(
          method.getProject(),
          DescriptiveNameUtil.getDescriptiveName(method), actionString, containingClass.isInterface() || superMethod.hasModifierProperty(PsiModifier.ABSTRACT),
          containingClass.isInterface(), aClass.isInterface(), containingClass.getQualifiedName()
      );
  dialog.show();

  if (dialog.getExitCode() == DialogWrapper.OK_EXIT_CODE) return superMethod;
  if (dialog.getExitCode() == SuperMethodWarningDialog.NO_EXIT_CODE) return method;

  return null;
}
 

import com.intellij.psi.PsiMethod; //导入方法依赖的package包/类
public MoveInstanceMethodDialogBase(PsiMethod method, PsiVariable[] variables, String refactoringName) {
  super(method.getProject(), true);
  myMethod = method;
  myVariables = variables;
  myRefactoringName = refactoringName;
  setTitle(myRefactoringName);
}
 

import com.intellij.psi.PsiMethod; //导入方法依赖的package包/类
public InlineParameterDialog(PsiCallExpression methodCall, PsiMethod method, PsiParameter psiParameter, PsiExpression initializer,
                             boolean createLocal) {
  super(method.getProject(), true);
  myMethodCall = methodCall;
  myMethod = method;
  myParameter = psiParameter;
  myInitializer = initializer;
  init();
  myCreateLocalCheckbox.setSelected(createLocal);
  setTitle(InlineParameterHandler.REFACTORING_NAME);
}
 

import com.intellij.psi.PsiMethod; //导入方法依赖的package包/类
@Override
protected JavaMethodNode createTreeNode(PsiMethod nodeMethod,
                                        com.intellij.util.containers.HashSet<PsiMethod> called,
                                        Runnable cancelCallback) {
  final MakeStaticJavaMethodNode node =
    new MakeStaticJavaMethodNode(nodeMethod, called, cancelCallback, nodeMethod != null ? nodeMethod.getProject() : myProject);
  if (getTopMethod().equals(nodeMethod)) {
    node.setEnabled(false);
    node.setChecked(true);
  }
  return node;
}
 

import com.intellij.psi.PsiMethod; //导入方法依赖的package包/类
private static SearchScope getUseScope(final PsiMethod method) {
  final SearchScope scope = method.getUseScope();
  final PsiFile file = method.getContainingFile();
  if (file != null && scope instanceof GlobalSearchScope) {
    final VirtualFile vfile = file.getOriginalFile().getVirtualFile();
    final Project project = method.getProject();
    if (vfile != null && ProjectRootManager.getInstance(project).getFileIndex().isInSource(vfile)) {
      return new GrSourceFilterScope((GlobalSearchScope)scope);
    }
  }
  return scope;
}
 

import com.intellij.psi.PsiMethod; //导入方法依赖的package包/类
@NotNull
public static PsiMethod[] checkSuperMethods(@NotNull PsiMethod method, @NotNull String actionString, @NotNull Collection<PsiElement> ignore) {
  PsiClass aClass = method.getContainingClass();
  if (aClass == null) return new PsiMethod[]{method};

  final Collection<PsiMethod> superMethods = DeepestSuperMethodsSearch.search(method).findAll();
  superMethods.removeAll(ignore);

  if (superMethods.isEmpty()) {
    PsiMethod siblingSuperMethod = FindSuperElementsHelper.getSiblingInheritedViaSubClass(method);
    if (siblingSuperMethod != null) {
      superMethods.add(siblingSuperMethod);
    }
  }
  if (superMethods.isEmpty()) return new PsiMethod[]{method};


  Set<String> superClasses = new HashSet<String>();
  boolean superAbstract = false;
  boolean parentInterface = false;
  for (final PsiMethod superMethod : superMethods) {
    final PsiClass containingClass = superMethod.getContainingClass();
    superClasses.add(containingClass.getQualifiedName());
    final boolean isInterface = containingClass.isInterface();
    superAbstract |= isInterface || superMethod.hasModifierProperty(PsiModifier.ABSTRACT);
    parentInterface |= isInterface;
  }

  SuperMethodWarningDialog dialog =
      new SuperMethodWarningDialog(method.getProject(), DescriptiveNameUtil.getDescriptiveName(method), actionString, superAbstract,
                                   parentInterface, aClass.isInterface(), ArrayUtil.toStringArray(superClasses));
  dialog.show();

  if (dialog.getExitCode() == DialogWrapper.OK_EXIT_CODE) {
    return superMethods.toArray(new PsiMethod[superMethods.size()]);
  }
  if (dialog.getExitCode() == SuperMethodWarningDialog.NO_EXIT_CODE) {
    return new PsiMethod[]{method};
  }

  return PsiMethod.EMPTY_ARRAY;
}