Java CommonRefactoringUtil.checkReadOnlyStatus方法代码示例

import com.intellij.refactoring.util.CommonRefactoringUtil; //导入方法依赖的package包/类
private void invoke(PsiClass aClass, Editor editor) {
  String qualifiedName = aClass.getQualifiedName();
  if(qualifiedName == null) {
    showJspOrLocalClassMessage(editor);
    return;
  }
  if (!checkAbstractClassOrInterfaceMessage(aClass, editor)) return;
  final PsiMethod[] constructors = aClass.getConstructors();
  if (constructors.length > 0) {
    String message =
            RefactoringBundle.message("class.does.not.have.implicit.default.constructor", aClass.getQualifiedName()) ;
    CommonRefactoringUtil.showErrorHint(myProject, editor, message, REFACTORING_NAME, HelpID.REPLACE_CONSTRUCTOR_WITH_FACTORY);
    return;
  }
  final int answer = Messages.showYesNoDialog(myProject,
                                              RefactoringBundle.message("would.you.like.to.replace.default.constructor.of.0.with.factory.method", aClass.getQualifiedName()),
                                              REFACTORING_NAME, Messages.getQuestionIcon()
  );
  if (answer != Messages.YES) return;
  if (!CommonRefactoringUtil.checkReadOnlyStatus(myProject, aClass)) return;
  new ReplaceConstructorWithFactoryDialog(myProject, null, aClass).show();
}
 

import com.intellij.refactoring.util.CommonRefactoringUtil; //导入方法依赖的package包/类
private static void invoke(PsiMethod method, final Project project) {
  if (!CommonRefactoringUtil.checkReadOnlyStatus(project, method)) return;
  if (method instanceof GrReflectedMethod) method = ((GrReflectedMethod)method).getBaseMethod();

  PsiMethod newMethod = SuperMethodWarningUtil.checkSuperMethod(method, RefactoringBundle.message("to.refactor"));
  if (newMethod == null) return;

  if (!newMethod.equals(method)) {
    ChangeSignatureUtil.invokeChangeSignatureOn(newMethod, project);
    return;
  }

  if (!CommonRefactoringUtil.checkReadOnlyStatus(project, method)) return;

  if (!(method instanceof GrMethod)) return; //todo
  final GrChangeSignatureDialog dialog = new GrChangeSignatureDialog(project, new GrMethodDescriptor((GrMethod)method), true, null);
  dialog.show();
}
 

import com.intellij.refactoring.util.CommonRefactoringUtil; //导入方法依赖的package包/类
public void invoke(@NotNull final Project project, Editor editor, final PsiFile file, DataContext dataContext) {
  if (!CommonRefactoringUtil.checkReadOnlyStatus(project, file)) return;

  final int offset = editor.getCaretModel().getOffset();
  editor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE);
  final PsiAnonymousClass anonymousClass = findAnonymousClass(file, offset);
  if (anonymousClass == null) {
    showErrorMessage(editor, RefactoringBundle.getCannotRefactorMessage(RefactoringBundle.message("error.wrong.caret.position.anonymous")));
    return;
  }
  final PsiElement parent = anonymousClass.getParent();
  if (parent instanceof PsiEnumConstant) {
    showErrorMessage(editor, RefactoringBundle.getCannotRefactorMessage("Enum constant can't be converted to inner class"));
    return;
  }
  invoke(project, editor, anonymousClass);
}
 

import com.intellij.refactoring.util.CommonRefactoringUtil; //导入方法依赖的package包/类
private static void invoke(final PsiClass aClass, Editor editor) {
  final PsiTypeParameterList typeParameterList = aClass.getTypeParameterList();
  Project project = aClass.getProject();
  if (typeParameterList == null) {
    final String message = RefactoringBundle.getCannotRefactorMessage(RefactoringBundle.message("changeClassSignature.no.type.parameters"));
    CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.CHANGE_CLASS_SIGNATURE);
    return;
  }
  if (!CommonRefactoringUtil.checkReadOnlyStatus(project, aClass)) return;

  ChangeClassSignatureDialog dialog = new ChangeClassSignatureDialog(aClass, true);
  //if (!ApplicationManager.getApplication().isUnitTestMode()){
  dialog.show();
  //}else {
  //  dialog.showAndGetOk()
  //}
}
 

import com.intellij.refactoring.util.CommonRefactoringUtil; //导入方法依赖的package包/类
public static void invoke(final Project project, Editor editor, final GrVariable local) {
  final PsiReference invocationReference = editor != null ? TargetElementUtil.findReference(editor) : null;

  final InlineLocalVarSettings localVarSettings = createSettings(local, editor, invocationReference != null);
  if (localVarSettings == null) return;

  if (!CommonRefactoringUtil.checkReadOnlyStatus(project, local)) return;

  final GroovyInlineLocalProcessor processor = new GroovyInlineLocalProcessor(project, localVarSettings, local);
  processor.setPrepareSuccessfulSwingThreadCallback(new Runnable() {
    @Override
    public void run() {
      //do nothing
    }
  });
  processor.run();
}
 

import com.intellij.refactoring.util.CommonRefactoringUtil; //导入方法依赖的package包/类
private boolean isWritable() {
  final Collection<PyMemberInfo<PyElement>> infos = myView.getSelectedMemberInfos();
  if (infos.isEmpty()) {
    return true;
  }
  final PyElement element = infos.iterator().next().getMember();
  final Project project = element.getProject();
  if (!CommonRefactoringUtil.checkReadOnlyStatus(project, myView.getSelectedParent())) return false;
  final PyClass container = PyUtil.getContainingClassOrSelf(element);
  if (container == null || !CommonRefactoringUtil.checkReadOnlyStatus(project, container)) return false;
  for (final PyMemberInfo<PyElement> info : infos) {
    final PyElement member = info.getMember();
    if (!CommonRefactoringUtil.checkReadOnlyStatus(project, member)) return false;
  }
  return true;
}
 

import com.intellij.refactoring.util.CommonRefactoringUtil; //导入方法依赖的package包/类
@Override
public void applyFix(@NotNull final Project project, @NotNull ProblemDescriptor descriptor) {
  final PsiElement element = descriptor.getPsiElement();
  final PsiMethod method = PsiTreeUtil.getParentOfType(element, PsiMethod.class);
  if (method == null) return;
  PsiParameter parameter = PsiTreeUtil.getParentOfType(element, PsiParameter.class, false);
  if (parameter == null) {
    final PsiParameter[] parameters = method.getParameterList().getParameters();
    for (PsiParameter psiParameter : parameters) {
      if (Comparing.strEqual(psiParameter.getName(), myParameterName)) {
        parameter = psiParameter;
        break;
      }
    }
  }
  if (parameter == null) return;
  if (!CommonRefactoringUtil.checkReadOnlyStatus(project, parameter)) return;

  final PsiExpression defToInline;
  try {
    defToInline = JavaPsiFacade.getInstance(project).getElementFactory().createExpressionFromText(myValue, parameter);
  }
  catch (IncorrectOperationException e) {
    return;
  }
  final PsiParameter parameterToInline = parameter;
  inlineSameParameterValue(method, parameterToInline, defToInline);
}
 

import com.intellij.refactoring.util.CommonRefactoringUtil; //导入方法依赖的package包/类
private boolean checkWritable(PsiClass superClass, MemberInfo[] infos) {
  if (!CommonRefactoringUtil.checkReadOnlyStatus(myProject, superClass)) return false;
  for (MemberInfo info : infos) {
    if (info.getMember() instanceof PsiClass && info.getOverrides() != null) continue;
    if (!CommonRefactoringUtil.checkReadOnlyStatus(myProject, info.getMember())) return false;
  }
  return true;
}
 

import com.intellij.refactoring.util.CommonRefactoringUtil; //导入方法依赖的package包/类
public static void checkRemoveUnusedField(final RadRootContainer rootContainer, final String fieldName, final Object undoGroupId) {
  final PsiField oldBindingField = findBoundField(rootContainer, fieldName);
  if (oldBindingField == null) {
    return;
  }
  final Project project = oldBindingField.getProject();
  final PsiClass aClass = oldBindingField.getContainingClass();
  if (isFieldUnreferenced(oldBindingField)) {
    if (!CommonRefactoringUtil.checkReadOnlyStatus(project, aClass)) {
      return;
    }
    ApplicationManager.getApplication().runWriteAction(
      new Runnable() {
        public void run() {
          CommandProcessor.getInstance().executeCommand(
            project,
            new Runnable() {
              public void run() {
                try {
                  oldBindingField.delete();
                }
                catch (IncorrectOperationException e) {
                  Messages.showErrorDialog(project, UIDesignerBundle.message("error.cannot.delete.unused.field", e.getMessage()),
                                           CommonBundle.getErrorTitle());
                }
              }
            },
            UIDesignerBundle.message("command.delete.unused.field"), undoGroupId
          );
        }
      }
    );
  }
}
 

import com.intellij.refactoring.util.CommonRefactoringUtil; //导入方法依赖的package包/类
public void invoke(@NotNull final Project project, @NotNull PsiElement[] elements, DataContext dataContext) {
  if (elements.length != 1) return;

  myProject = project;
  myClass = (PsiClass)elements[0];


  if (!CommonRefactoringUtil.checkReadOnlyStatus(project, myClass)) return;

  final ExtractInterfaceDialog dialog = new ExtractInterfaceDialog(myProject, myClass);
  if (!dialog.showAndGet() || !dialog.isExtractSuperclass()) {
    return;
  }
  final MultiMap<PsiElement, String> conflicts = new MultiMap<PsiElement, String>();
  ExtractSuperClassUtil.checkSuperAccessible(dialog.getTargetDirectory(), conflicts, myClass);
  if (!ExtractSuperClassUtil.showConflicts(dialog, conflicts, myProject)) return;
  CommandProcessor.getInstance().executeCommand(myProject, new Runnable() {
    public void run() {
      ApplicationManager.getApplication().runWriteAction(new Runnable() {
        public void run() {
          myInterfaceName = dialog.getExtractedSuperName();
          mySelectedMembers = ArrayUtil.toObjectArray(dialog.getSelectedMemberInfos(), MemberInfo.class);
          myTargetDir = dialog.getTargetDirectory();
          myJavaDocPolicy = new DocCommentPolicy(dialog.getDocCommentPolicy());
          try {
            doRefactoring();
          }
          catch (IncorrectOperationException e) {
            LOG.error(e);
          }
        }
      });
    }
  }, REFACTORING_NAME, null);
}
 

import com.intellij.refactoring.util.CommonRefactoringUtil; //导入方法依赖的package包/类
@Override
  public void invoke(@NotNull final Project project, @NotNull PsiElement[] elements, DataContext dataContext) {
    if (elements.length != 1) return;


    myProject = project;
    myClass = (PsiClass)elements[0];


    if (!CommonRefactoringUtil.checkReadOnlyStatus(project, myClass)) return;

/* todo
    final JavaExtractSuperBaseDialog dialog = new ExtractInterfaceDialog(myProject, myClass);
    dialog.show();
    if (!dialog.isOK() || !dialog.isExtractSuperclass()) return;

    final MultiMap<PsiElement, String> conflicts = new MultiMap<PsiElement, String>();
    ExtractSuperClassUtil.checkSuperAccessible(dialog.getTargetDirectory(), conflicts, myClass);
    if (!ExtractSuperClassUtil.showConflicts(dialog, conflicts, myProject)) return;

    CommandProcessor.getInstance().executeCommand(myProject, new Runnable() {
      public void run() {
        ApplicationManager.getApplication().runWriteAction(new Runnable() {
          public void run() {
            myInterfaceName = dialog.getExtractedSuperName();
            mySelectedMembers = ArrayUtil.toObjectArray(dialog.getSelectedMemberInfos(), MemberInfo.class);
            myTargetDir = dialog.getTargetDirectory();
            myJavaDocPolicy = new DocCommentPolicy(dialog.getDocCommentPolicy());
            try {
              doRefactoring();
            }
            catch (IncorrectOperationException e) {
              LOG.error(e);
            }
          }
        });
      }
    }, REFACTORING_NAME, null);*/
  }
 

import com.intellij.refactoring.util.CommonRefactoringUtil; //导入方法依赖的package包/类
static void extractMethodObject(Project project, Editor editor, ExtractMethodObjectProcessor processor) throws PrepareFailedException {
  final ExtractMethodObjectProcessor.MyExtractMethodProcessor extractProcessor = processor.getExtractProcessor();
  if (!extractProcessor.prepare()) return;
  if (!CommonRefactoringUtil.checkReadOnlyStatus(project, extractProcessor.getTargetClass().getContainingFile())) return;
  if (extractProcessor.showDialog()) {
    run(project, editor, processor, extractProcessor);
  }
}
 

import com.intellij.refactoring.util.CommonRefactoringUtil; //导入方法依赖的package包/类
private static boolean invokeOnElements(final Project project, final Editor editor, @NotNull final ExtractMethodProcessor processor, final boolean directTypes) {
  if (!CommonRefactoringUtil.checkReadOnlyStatus(project, processor.getTargetClass().getContainingFile())) return false;
  if (processor.showDialog(directTypes)) {
    run(project, editor, processor);
    DuplicatesImpl.processDuplicates(processor, project, editor);
    return true;
  }
  return false;
}
 

import com.intellij.refactoring.util.CommonRefactoringUtil; //导入方法依赖的package包/类
public void invoke(Project project, PsiExpression[] expressions) {
  for (PsiExpression expression : expressions) {
    final PsiFile file = expression.getContainingFile();
    if (!CommonRefactoringUtil.checkReadOnlyStatus(project, file)) return;
  }
  PsiDocumentManager.getInstance(project).commitAllDocuments();
  super.invoke(project, expressions, null);
}
 

import com.intellij.refactoring.util.CommonRefactoringUtil; //导入方法依赖的package包/类
private boolean invoke(final Project project, final Editor editor, PsiFile file, int startOffset, int endOffset) {
  try {
    PsiDocumentManager.getInstance(project).commitAllDocuments();
    if (!(file instanceof LuaPsiFileBase)) {
      throw new LuaIntroduceRefactoringError("Only Lua files");
    }
    if (!CommonRefactoringUtil.checkReadOnlyStatus(project, file)) {
      throw new LuaIntroduceRefactoringError("Read-only occurances found");
    }

    LuaExpression selectedExpr = findExpression((LuaPsiFileBase)file, startOffset, endOffset);
    final LuaSymbol variable = findVariable((LuaPsiFile)file, startOffset, endOffset);
    if (variable != null) {
      checkVariable(variable);
    }
    else if (selectedExpr != null) {
      checkExpression(selectedExpr);
    }
    else {
      throw new LuaIntroduceRefactoringError(null);
    }

    final LuaIntroduceContext context = getContext(project, editor, selectedExpr, variable);
    checkOccurrences(context.occurrences);
    final Settings settings = showDialog(context);
    if (settings == null) return false;

    CommandProcessor.getInstance().executeCommand(context.project, new Runnable() {
    public void run() {
      ApplicationManager.getApplication().runWriteAction(new Computable<LuaSymbol>() {
        public LuaSymbol compute() {
          return runRefactoring(context, settings);
        }
      });
    }
  }, getRefactoringName(), null);

    return true;
  }
  catch (LuaIntroduceRefactoringError e) {
    CommonRefactoringUtil
      .showErrorHint(project, editor, RefactoringBundle.getCannotRefactorMessage(e.getMessage()), getRefactoringName(), getHelpID());
    return false;
  }
}