com.intellij.psi.util.PsiUtil#setModifierProperty ( )源码实例Demo

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);
        }
    }
}
 

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;
}
 

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 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 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;
}
 

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;
}
 

@Override
public void run() {
    final PsiClass targetClass = InnerBuilderUtils.getStaticOrTopLevelClass(file, editor);
    if (targetClass == null) {
        return;
    }
    final Set<InnerBuilderOption> options = currentOptions();
    final PsiClass builderClass = findOrCreateBuilderClass(targetClass);
    final PsiType builderType = psiElementFactory.createTypeFromText(BUILDER_CLASS_NAME, null);
    final PsiMethod constructor = generateConstructor(targetClass, builderType);

    addMethod(targetClass, null, constructor, true);
    final Collection<PsiFieldMember> finalFields = new ArrayList<PsiFieldMember>();
    final Collection<PsiFieldMember> nonFinalFields = new ArrayList<PsiFieldMember>();

    PsiElement lastAddedField = null;
    for (final PsiFieldMember fieldMember : selectedFields) {
        lastAddedField = findOrCreateField(builderClass, fieldMember, lastAddedField);
        if (fieldMember.getElement().hasModifierProperty(PsiModifier.FINAL)
                && !options.contains(InnerBuilderOption.FINAL_SETTERS)) {
            finalFields.add(fieldMember);
            PsiUtil.setModifierProperty((PsiField) lastAddedField, PsiModifier.FINAL, true);
        } else {
            nonFinalFields.add(fieldMember);
        }
    }
    if (options.contains(InnerBuilderOption.NEW_BUILDER_METHOD)) {
        final PsiMethod newBuilderMethod = generateNewBuilderMethod(builderType, finalFields, options);
        addMethod(targetClass, null, newBuilderMethod, false);
    }

    // builder constructor, accepting the final fields
    final PsiMethod builderConstructorMethod = generateBuilderConstructor(builderClass, finalFields, options);
    addMethod(builderClass, null, builderConstructorMethod, false);

    // builder copy constructor or static copy method
    if (options.contains(InnerBuilderOption.COPY_CONSTRUCTOR)) {
        if (options.contains(InnerBuilderOption.NEW_BUILDER_METHOD)) {
            final PsiMethod copyBuilderMethod = generateCopyBuilderMethod(targetClass, builderType,
                    nonFinalFields, options);
            addMethod(targetClass, null, copyBuilderMethod, true);
        } else {
            final PsiMethod copyConstructorBuilderMethod = generateCopyConstructor(targetClass, builderType,
                    selectedFields, options);
            addMethod(builderClass, null, copyConstructorBuilderMethod, true);
        }
    }

    // builder methods
    PsiElement lastAddedElement = null;
    for (final PsiFieldMember member : nonFinalFields) {
        final PsiMethod setterMethod = generateBuilderSetter(builderType, member, options);
        lastAddedElement = addMethod(builderClass, lastAddedElement, setterMethod, false);
    }

    // builder.build() method
    final PsiMethod buildMethod = generateBuildMethod(targetClass, options);
    addMethod(builderClass, lastAddedElement, buildMethod, false);

    JavaCodeStyleManager.getInstance(project).shortenClassReferences(file);
    CodeStyleManager.getInstance(project).reformat(builderClass);
}