Java PsiUtil.addException方法代码示例

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Override
public void invoke(@NotNull Project project,
                   @NotNull PsiFile file,
                   @Nullable("is null when called from inspection") Editor editor,
                   @NotNull PsiElement startElement,
                   @NotNull PsiElement endElement) {
  final PsiClass myClass = (PsiClass)startElement;
  if (!FileModificationService.getInstance().prepareFileForWrite(myClass.getContainingFile())) return;
  PsiCodeBlock body;
  if (myClass.isInterface() && (body = myMethodPrototype.getBody()) != null) body.delete();
  for (String exception : myExceptions) {
    PsiUtil.addException(myMethodPrototype, exception);
  }
  PsiMethod method = (PsiMethod)myClass.add(myMethodPrototype);
  method = (PsiMethod)method.replace(reformat(project, method));
  postAddAction(file, editor, method);
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
private static void processMethod(@NotNull Project project,
                                  @NotNull PsiMethod targetMethod,
                                  @NotNull Set<PsiClassType> unhandledExceptions) throws IncorrectOperationException {
  for (PsiClassType unhandledException : unhandledExceptions) {
    PsiClass exceptionClass = unhandledException.resolve();
    if (exceptionClass != null) {
      PsiUtil.addException(targetMethod, exceptionClass);
    }
  }

  CodeStyleManager.getInstance(project).reformat(targetMethod.getThrowsList());
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Override
protected void performRefactoring(@NotNull UsageInfo[] usages) {
  final List<PsiClassType> thrownExceptions = ExceptionUtil.getThrownCheckedExceptions(new PsiElement[]{myInitializer});
  final Set<PsiVariable> varsUsedInInitializer = new HashSet<PsiVariable>();
  final Set<PsiJavaCodeReferenceElement> paramRefsToInline = new HashSet<PsiJavaCodeReferenceElement>();
  final Map<PsiElement, PsiElement> replacements = new HashMap<PsiElement, PsiElement>();
  for (UsageInfo usage : usages) {
    if (usage instanceof LocalReplacementUsageInfo) {
      final LocalReplacementUsageInfo replacementUsageInfo = (LocalReplacementUsageInfo)usage;
      final PsiElement element = replacementUsageInfo.getElement();
      final PsiElement replacement = replacementUsageInfo.getReplacement();
      if (element != null && replacement != null) {
        replacements.put(element, replacement);
      }
      varsUsedInInitializer.add(replacementUsageInfo.getVariable());
    }
    else {
      LOG.assertTrue(!myCreateLocal);
      paramRefsToInline.add((PsiJavaCodeReferenceElement)usage.getElement());
    }
  }
  myInitializer = (PsiExpression)RefactoringUtil.replaceElementsWithMap(myInitializer, replacements);

  if (myCreateLocal) {
    final PsiElementFactory factory = JavaPsiFacade.getInstance(myMethod.getProject()).getElementFactory();
    PsiDeclarationStatement localDeclaration =
      factory.createVariableDeclarationStatement(myParameter.getName(), myParameter.getType(), myInitializer);
    final PsiLocalVariable declaredVar = (PsiLocalVariable)localDeclaration.getDeclaredElements()[0];
    PsiUtil.setModifierProperty(declaredVar, PsiModifier.FINAL, myParameter.hasModifierProperty(PsiModifier.FINAL));
    final PsiExpression localVarInitializer =
      InlineUtil.inlineVariable(myParameter, myInitializer, (PsiReferenceExpression)factory.createExpressionFromText(myParameter.getName(), myMethod));
    final PsiExpression initializer = declaredVar.getInitializer();
    LOG.assertTrue(initializer != null);
    initializer.replace(localVarInitializer);
    final PsiCodeBlock body = myMethod.getBody();
    if (body != null) {
      PsiElement anchor = findAnchorForLocalVariableDeclaration(body);
      body.addAfter(localDeclaration, anchor);
    }
  } else {
    for (PsiJavaCodeReferenceElement paramRef : paramRefsToInline) {
      InlineUtil.inlineVariable(myParameter, myInitializer, paramRef);
    }
  }

  //delete var if it becomes unused
  for (PsiVariable variable : varsUsedInInitializer) {
    if (variable != null && variable.isValid()) {
      if (ReferencesSearch.search(variable).findFirst() == null) {
        variable.delete();
      }
    }
  }

  SameParameterValueInspection.InlineParameterValueFix.removeParameter(myMethod, myParameter);

  if (!thrownExceptions.isEmpty()) {
    for (PsiClassType exception : thrownExceptions) {
      PsiClass exceptionClass = exception.resolve();
      if (exceptionClass != null) {
        PsiUtil.addException(myMethod, exceptionClass);
      }
    }
  }
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Override
public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException {
  final PsiElement methodNameIdentifier = descriptor.getPsiElement();
  final PsiMethod method = (PsiMethod)methodNameIdentifier.getParent();
  PsiUtil.addException(method, "java.lang.CloneNotSupportedException");
}