com.intellij.psi.codeStyle.JavaCodeStyleManager Java Examples

public static void doOptimize(Project project) {
    DumbService.getInstance(project).runWhenSmart((DumbAwareRunnable) () -> new WriteCommandAction(project) {
        @Override
        protected void run(@NotNull Result result) {
            for (VirtualFile virtualFile : virtualFiles) {
                try {
                    PsiJavaFile javaFile = (PsiJavaFile) PsiManager.getInstance(project).findFile(virtualFile);
                    if (javaFile != null) {
                        CodeStyleManager.getInstance(project).reformat(javaFile);
                        JavaCodeStyleManager.getInstance(project).optimizeImports(javaFile);
                        JavaCodeStyleManager.getInstance(project).shortenClassReferences(javaFile);
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            virtualFiles.clear();
        }
    }.execute());
}
 

@Override
public void build(PsiFile psiFile, Project project1, Editor editor) {
    if (psiFile == null) return;
    WriteCommandAction.runWriteCommandAction(project1, () -> {
        if (editor == null) return;
        Project project = editor.getProject();
        if (project == null) return;
        PsiElement mouse = psiFile.findElementAt(editor.getCaretModel().getOffset());
        PsiClass psiClass = PsiTreeUtil.getParentOfType(mouse, PsiClass.class);
        if (psiClass == null) return;

        if (psiClass.getNameIdentifier() == null) return;
        String className = psiClass.getNameIdentifier().getText();

        PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(project);

        build(editor, mouse, elementFactory, project, psiClass, psiFile, className);

        JavaCodeStyleManager styleManager = JavaCodeStyleManager.getInstance(project);
        styleManager.optimizeImports(psiFile);
        styleManager.shortenClassReferences(psiClass);

    });
}
 

@Override
public void run() throws Throwable {
    final IButterKnife butterKnife = ButterKnifeFactory.findButterKnifeForPsiElement(mProject, mFile);
    if (butterKnife == null) {
        return; // Butterknife library is not available for project
    }

    if (mCreateHolder) {
        generateAdapter(butterKnife);
    } else {
        if (Utils.getInjectCount(mElements) > 0) {
            generateFields(butterKnife);
        }
        generateInjects(butterKnife);
        if (Utils.getClickCount(mElements) > 0) {
            generateClick();
        }
        Utils.showInfoNotification(mProject, String.valueOf(Utils.getInjectCount(mElements)) + " injections and " + String.valueOf(Utils.getClickCount(mElements)) + " onClick added to " + mFile.getName());
    }

    // reformat class
    JavaCodeStyleManager styleManager = JavaCodeStyleManager.getInstance(mProject);
    styleManager.optimizeImports(mFile);
    styleManager.shortenClassReferences(mClass);
    new ReformatCodeProcessor(mProject, mClass.getContainingFile(), null, false).runWithoutProgress();
}
 

@Override
public void invoke(@NotNull Project project, @NotNull PsiFile file, @NotNull PsiElement startElement,
                   @NotNull PsiElement endElement) {
  super.invoke(project, file, startElement, endElement);

  final PsiNamedElement psiNamedElement = elementToRemove.getElement();
  if (null != psiNamedElement) {
    final Collection<PsiReference> all = ReferencesSearch.search(psiNamedElement).findAll();

    final String loggerName = getLoggerName(PsiTreeUtil.getParentOfType(psiNamedElement, PsiClass.class));
    for (PsiReference psiReference : all) {
      psiReference.handleElementRename(loggerName);
    }

    psiNamedElement.delete();

    JavaCodeStyleManager.getInstance(project).removeRedundantImports((PsiJavaFile) file);
  }
}
 

@Override
protected void run(@NotNull Result<PsiFile> result) throws Throwable {
    final PsiPackage packageElement = directoryService.getPackage(directory);
    if (packageElement == null) {
        throw new InvalidDirectoryException("Target directory does not provide a package");
    }

    final String fileName = Extensions.append(name, StdFileTypes.JAVA);
    final PsiFile found = directory.findFile(fileName);
    if (found != null) {
        throw new ClassAlreadyExistsException("Class '" + name + "'already exists in " + packageElement.getName());
    }

    final String packageName = packageElement.getQualifiedName();
    final String className = Extensions.remove(this.name, StdFileTypes.JAVA);
    try {
        final String java = converter.convert(packageName, className, json);
        final PsiFile classFile = fileFactory.createFileFromText(fileName, JavaFileType.INSTANCE, java);
        CodeStyleManager.getInstance(classFile.getProject()).reformat(classFile);
        JavaCodeStyleManager.getInstance(classFile.getProject()).optimizeImports(classFile);
        final PsiFile created = (PsiFile) directory.add(classFile);
        result.setResult(created);
    } catch (IOException e) {
        throw new ClassCreationException("Failed to create new class from JSON", e);
    }
}
 

private void addAnnotation(@NotNull PsiModifierListOwner targetElement, @NotNull PsiAnnotation newPsiAnnotation,
                           @NotNull Class<? extends Annotation> annotationClass) {
  final PsiAnnotation presentAnnotation = PsiAnnotationSearchUtil.findAnnotation(targetElement, annotationClass);

  final Project project = targetElement.getProject();
  final JavaCodeStyleManager javaCodeStyleManager = JavaCodeStyleManager.getInstance(project);
  javaCodeStyleManager.shortenClassReferences(newPsiAnnotation);

  if (null == presentAnnotation) {
    PsiModifierList modifierList = targetElement.getModifierList();
    if (null != modifierList) {
      modifierList.addAfter(newPsiAnnotation, null);
    }
  } else {
    presentAnnotation.setDeclaredAttributeValue(PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME,
      newPsiAnnotation.findDeclaredAttributeValue(PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME));
  }
}
 

/**
 * Make the class implementing Parcelable
 */
private void makeClassImplementParcelable(PsiElementFactory elementFactory, JavaCodeStyleManager styleManager) {
  final PsiClassType[] implementsListTypes = psiClass.getImplementsListTypes();
  final String implementsType = "android.os.Parcelable";

  for (PsiClassType implementsListType : implementsListTypes) {
    PsiClass resolved = implementsListType.resolve();

    // Already implements Parcelable, no need to add it
    if (resolved != null && implementsType.equals(resolved.getQualifiedName())) {
      return;
    }
  }

  PsiJavaCodeReferenceElement implementsReference =
      elementFactory.createReferenceFromText(implementsType, psiClass);
  PsiReferenceList implementsList = psiClass.getImplementsList();

  if (implementsList != null) {
    styleManager.shortenClassReferences(implementsList.add(implementsReference));
  }
}
 

private boolean addExtendInterfaces(ClassInfo info, JavaCodeStyleManager styleManager,
                                    PsiElementFactory elementFactory, PsiClass psic) {
    List<String> interfaces = info.getInterfaces();
    if(interfaces != null){
        PsiReferenceList list = psic.getExtendsList();
        if(list == null){
            Util.log(" psic.getExtendsList() == null");
            return false;
        }
        for(String inter : interfaces){
            PsiJavaCodeReferenceElement reference = elementFactory.createReferenceFromText(inter, psic);
            styleManager.shortenClassReferences(reference);
            list.add(reference);
        }
    }
    return true;
}
 

@Override
public void makeInterfaceExtend(PsiClass mClass, PsiElementFactory elementFactory, JavaCodeStyleManager styleManager) {
    // get extend interfaces.
    final PsiClassType[] implementsListTypes = mClass.getExtendsListTypes();
    final String implementsType = "com.heaven7.java.data.mediator.DataPools.Poolable";

    for (PsiClassType implementsListType : implementsListTypes) {
        PsiClass resolved = implementsListType.resolve();

        // Already implements Parcelable, no need to add it
        if (resolved != null && implementsType.equals(resolved.getQualifiedName())) {
            return;
        }
    }
    PsiJavaCodeReferenceElement implementsReference = elementFactory.createReferenceFromText(implementsType, mClass);
    PsiReferenceList implementsList = mClass.getExtendsList();
    if (implementsList != null) {
        styleManager.shortenClassReferences(implementsReference);
        implementsList.add(implementsReference);
    }
}
 

public GodClassPreviewResultDialog(@NotNull Project project, @NotNull MutableDiffRequestChain requestChain,
                                   @NotNull DiffDialogHints hints, ExtractClassPreviewProcessor previewProcessor) {
    super(project, requestChain, hints);
    this.myChain = requestChain;
    this.project = project;
    this.diffContentFactory = DiffContentFactory.getInstance();
    this.previewProcessor = previewProcessor;
    this.javaCodeStyleManager = JavaCodeStyleManager.getInstance(project);
    this.codeStyleManager = CodeStyleManager.getInstance(project);
}
 

public void generate() {
    PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(mClass.getProject());

    removeExistingParcelableImplementation(mClass);

    // Describe contents method
    PsiMethod describeContentsMethod = elementFactory.createMethodFromText(generateDescribeContents(), mClass);
    // Method for writing to the parcel
    PsiMethod writeToParcelMethod = elementFactory.createMethodFromText(generateWriteToParcel(mFields), mClass);

    // Default constructor if needed
    String defaultConstructorString = generateDefaultConstructor(mClass);
    PsiMethod defaultConstructor = null;

    if (defaultConstructorString != null) {
        defaultConstructor = elementFactory.createMethodFromText(defaultConstructorString, mClass);
    }

    // Constructor
    PsiMethod constructor = elementFactory.createMethodFromText(generateConstructor(mFields, mClass), mClass);
    // CREATOR
    PsiField creatorField = elementFactory.createFieldFromText(generateStaticCreator(mClass), mClass);

    JavaCodeStyleManager styleManager = JavaCodeStyleManager.getInstance(mClass.getProject());

    // Shorten all class references
    styleManager.shortenClassReferences(mClass.addBefore(describeContentsMethod, mClass.getLastChild()));
    styleManager.shortenClassReferences(mClass.addBefore(writeToParcelMethod, mClass.getLastChild()));

    // Only adds if available
    if (defaultConstructor != null) {
        styleManager.shortenClassReferences(mClass.addBefore(defaultConstructor, mClass.getLastChild()));
    }

    styleManager.shortenClassReferences(mClass.addBefore(constructor, mClass.getLastChild()));
    styleManager.shortenClassReferences(mClass.addBefore(creatorField, mClass.getLastChild()));

    makeClassImplementParcelable(elementFactory);
}
 

/**
 * Add the @Parcelable annotation if not already annotated
 */
private void addAnnotation(PsiElementFactory elementFactory, JavaCodeStyleManager styleManager) {

  boolean annotated = AnnotationUtil.isAnnotated(psiClass, ANNOTATION_PACKAGE+"."+ANNOTATION_NAME, false);

  if (!annotated) {
    styleManager.shortenClassReferences(psiClass.getModifierList().addAnnotation(
        ANNOTATION_NAME));
  }
}
 

/**
 * Generate and insert the Parcel and ParcelablePlease code
 */
public void generate() {

  PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(psiClass.getProject());
  JavaCodeStyleManager styleManager = JavaCodeStyleManager.getInstance(psiClass.getProject());

  // Clear any previous
  clearPrevious();

  // Implements parcelable
  makeClassImplementParcelable(elementFactory, styleManager);

  // @ParcelablePlease Annotation
  addAnnotation(elementFactory, styleManager);

  // Creator
  PsiField creatorField = elementFactory.createFieldFromText(generateCreator(), psiClass);

  // Describe contents method
  PsiMethod describeContentsMethod =
      elementFactory.createMethodFromText(generateDescribeContents(), psiClass);

  // Method for writing to the parcel
  PsiMethod writeToParcelMethod =
      elementFactory.createMethodFromText(generateWriteToParcel(), psiClass);

  styleManager.shortenClassReferences(
      psiClass.addBefore(describeContentsMethod, psiClass.getLastChild()));

  styleManager.shortenClassReferences(
      psiClass.addBefore(writeToParcelMethod, psiClass.getLastChild()));

  styleManager.shortenClassReferences(psiClass.addBefore(creatorField, psiClass.getLastChild()));
}
 

protected void formatJavCode(PsiClass cls) {
    if (cls == null) {
        return;
    }
    JavaCodeStyleManager styleManager = JavaCodeStyleManager.getInstance(cls.getProject());
    styleManager.optimizeImports(cls.getContainingFile());
    styleManager.shortenClassReferences(cls);
}
 

protected PsiFile createFile(Project project, @NotNull PsiDirectory psiDirectory, String fileName, String context, FileType fileType) {
    PsiFile psiFile = PsiFileFactory.getInstance(project).createFileFromText(fileName, fileType, context);
    // reformat class
    CodeStyleManager.getInstance(project).reformat(psiFile);
    if (psiFile instanceof PsiJavaFile) {
        JavaCodeStyleManager styleManager = JavaCodeStyleManager.getInstance(project);
        styleManager.optimizeImports(psiFile);
        styleManager.shortenClassReferences(psiFile);
    }
    // TODO: 加入覆盖判断
    psiDirectory.add(psiFile);
    return psiFile;
}
 

@Before
@Override
public void setUp() throws Exception {
    super.setUp();
    final Project project = getProject();
    final JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(project);
    underTest = new ParameterNamePolicy(codeStyleManager);
}
 

@Before
@Override
public void setUp() throws Exception {
    super.setUp();
    final Project project = getProject();
    final JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(project);
    underTest = new FieldNamePolicy(codeStyleManager);
}
 

@NotNull
public static PsiAnnotation addOrReplaceConcernAnnotation( @NotNull PsiModifierListOwner modifierListOwner,
                                                           @NotNull PsiClass concernClassToAdd )
{
    Project project = modifierListOwner.getProject();
    JavaPsiFacade psiFacade = JavaPsiFacade.getInstance( project );
    PsiElementFactory factory = psiFacade.getElementFactory();
    PsiAnnotation existingConcernsAnnotation = findAnnotation( modifierListOwner, QUALIFIED_NAME_CONCERNS );

    boolean isReplace = false;
    PsiAnnotation newConcernsAnnotation;
    if( existingConcernsAnnotation != null )
    {
        // Check duplicate
        List<PsiAnnotationMemberValue> concernsValues = getConcernsAnnotationValue( existingConcernsAnnotation );
        for( PsiAnnotationMemberValue concernValue : concernsValues )
        {
            PsiJavaCodeReferenceElement concernClassReference = getConcernClassReference( concernValue );
            if( concernClassReference == null )
            {
                continue;
            }

            PsiElement concernClass = concernClassReference.resolve();
            if( concernClassToAdd.equals( concernClass ) )
            {
                return existingConcernsAnnotation;
            }
        }

        isReplace = true;
    }

    String concernAnnotationText = createConcernAnnotationText( existingConcernsAnnotation, concernClassToAdd );
    newConcernsAnnotation =
        factory.createAnnotationFromText( concernAnnotationText, modifierListOwner );

    if( isReplace )
    {
        // Replace @Concerns instead
        existingConcernsAnnotation.replace( newConcernsAnnotation );
    }
    else
    {
        // @Concerns doesn't exists, add it as first child
        PsiModifierList modifierList = modifierListOwner.getModifierList();
        modifierList.addBefore( newConcernsAnnotation, modifierList.getFirstChild() );
    }

    // Shorten all class references if possible
    JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance( project );
    codeStyleManager.shortenClassReferences( newConcernsAnnotation );

    return newConcernsAnnotation;
}
 

@NotNull
public static PsiAnnotation addOrReplaceMixinAnnotation( @NotNull PsiModifierListOwner modifierListOwner,
                                                         @NotNull PsiClass mixinClassToAdd )
{
    Project project = modifierListOwner.getProject();
    JavaPsiFacade psiFacade = JavaPsiFacade.getInstance( project );
    PsiElementFactory factory = psiFacade.getElementFactory();
    PsiAnnotation existingMixinsAnnotation = findAnnotation( modifierListOwner, QUALIFIED_NAME_MIXINS );

    boolean isReplace = false;
    PsiAnnotation newMixinsAnnotation;
    if( existingMixinsAnnotation != null )
    {
        // Check duplicate
        List<PsiAnnotationMemberValue> mixinsValues = getMixinsAnnotationValue( existingMixinsAnnotation );
        for( PsiAnnotationMemberValue mixinValue : mixinsValues )
        {
            PsiJavaCodeReferenceElement mixinClassReference = getMixinClassReference( mixinValue );
            if( mixinClassReference == null )
            {
                continue;
            }

            PsiElement mixinClass = mixinClassReference.resolve();
            if( mixinClassToAdd.equals( mixinClass ) )
            {
                return existingMixinsAnnotation;
            }
        }

        isReplace = true;
    }

    String mixinsAnnotationText = createMixinsAnnotationText( existingMixinsAnnotation, mixinClassToAdd );
    newMixinsAnnotation = factory.createAnnotationFromText( mixinsAnnotationText, modifierListOwner );

    if( isReplace )
    {
        // Replace @Mixins instead
        existingMixinsAnnotation.replace( newMixinsAnnotation );
    }
    else
    {
        // @Mixins doesn't exists, add it as first child
        PsiModifierList modifierList = modifierListOwner.getModifierList();
        modifierList.addBefore( newMixinsAnnotation, modifierList.getFirstChild() );
    }

    // Shorten all class references if possible
    JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance( project );
    codeStyleManager.shortenClassReferences( newMixinsAnnotation );

    return newMixinsAnnotation;
}
 

@Override
public void invoke(@NotNull Project project, Editor editor, PsiFile psiFile) throws IncorrectOperationException {
    DocumentUtil.writeInRunUndoTransparentAction(new Runnable() {
        @Override
        public void run() {
            List<AndroidView> androidViews = AndroidUtils.getIDsFromXML(xmlFile);

            PsiStatement psiStatement = PsiTreeUtil.getParentOfType(psiElement, PsiStatement.class);
            if (psiStatement == null) {
                return;
            }

            PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(psiStatement.getProject());

            PsiElement[] localVariables = PsiTreeUtil.collectElements(psiStatement.getParent(), new PsiElementFilter() {
                @Override
                public boolean isAccepted(PsiElement element) {
                    return element instanceof PsiLocalVariable;
                }
            });

            Set<String> variables = new HashSet<String>();
            for (PsiElement localVariable : localVariables) {
                variables.add(((PsiLocalVariable) localVariable).getName());
            }

            for (AndroidView v : androidViews) {
                if (!variables.contains(v.getFieldName())) {
                    String sb1;

                    if (variableName != null) {
                        sb1 = String.format("%s %s = (%s) %s.findViewById(%s);", v.getName(), v.getFieldName(), v.getName(), variableName, v.getId());
                    } else {
                        sb1 = String.format("%s %s = (%s) findViewById(%s);", v.getName(), v.getFieldName(), v.getName(), v.getId());
                    }

                    PsiStatement statementFromText = elementFactory.createStatementFromText(sb1, null);
                    psiStatement.getParent().addAfter(statementFromText, psiStatement);
                }
            }

            JavaCodeStyleManager.getInstance(psiStatement.getProject()).shortenClassReferences(psiStatement.getParent());
            new ReformatAndOptimizeImportsProcessor(psiStatement.getProject(), psiStatement.getContainingFile(), true).run();

        }
    });

}
 

@Override
public void invoke(@NotNull Project project, Editor editor, PsiFile psiFile) throws IncorrectOperationException {

    DocumentUtil.writeInRunUndoTransparentAction(new Runnable() {
        @Override
        public void run() {
            List<AndroidView> androidViews = AndroidUtils.getIDsFromXML(xmlFile);

            PsiStatement psiStatement = PsiTreeUtil.getParentOfType(psiElement, PsiStatement.class);
            if(psiStatement == null) {
                return;
            }

            // collection class field
            // check if we need to set them
            PsiClass psiClass = PsiTreeUtil.getParentOfType(psiStatement, PsiClass.class);
            Set<String> fieldSet = new HashSet<String>();
            for(PsiField field: psiClass.getFields()) {
                fieldSet.add(field.getName());
            }

            // collect this.foo = "" and (this.)foo = ""
            // collection already init variables
            final Set<String> thisSet = new HashSet<String>();
            PsiTreeUtil.processElements(psiStatement.getParent(), new PsiElementProcessor() {

                @Override
                public boolean execute(@NotNull PsiElement element) {

                    if(element instanceof PsiThisExpression) {
                        attachFieldName(element.getParent());
                    } else if(element instanceof PsiAssignmentExpression) {
                       attachFieldName(((PsiAssignmentExpression) element).getLExpression());
                    }

                    return true;
                }

                private void attachFieldName(PsiElement psiExpression) {

                    if(!(psiExpression instanceof PsiReferenceExpression)) {
                        return;
                    }

                    PsiElement psiField = ((PsiReferenceExpression) psiExpression).resolve();
                    if(psiField instanceof PsiField) {
                        thisSet.add(((PsiField) psiField).getName());
                    }
                }
            });


            PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(psiStatement.getProject());
            for (AndroidView v: androidViews) {

                if(!fieldSet.contains(v.getFieldName())) {
                    String sb = "private " + v.getName() + " " + v.getFieldName() + ";";
                    psiClass.add(elementFactory.createFieldFromText(sb, psiClass));
                }

                if(!thisSet.contains(v.getFieldName())) {

                    String sb1;
                    if(variableName != null) {
                        sb1 = String.format("this.%s = (%s) %s.findViewById(%s);", v.getFieldName(), v.getName(), variableName, v.getId());
                    } else {
                        sb1 = String.format("this.%s = (%s) findViewById(%s);", v.getFieldName(), v.getName(), v.getId());
                    }


                    PsiStatement statementFromText = elementFactory.createStatementFromText(sb1, null);

                    psiStatement.getParent().addAfter(statementFromText, psiStatement);
                }

            }

            JavaCodeStyleManager.getInstance(psiStatement.getProject()).shortenClassReferences(psiStatement.getParent());
            new ReformatAndOptimizeImportsProcessor(psiStatement.getProject(), psiStatement.getContainingFile(), true).run();

        }
    });

}
 

/**
 * 1， add Override for super properties.
 * 2, generate super.
 * 3, remove fields/methods which have no annotation of @Keep and @ImplMethod.
 */
void generate() {
    final Project project = mPsiClass.getProject();
    PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(project);
    //remove exist method
    removeExistingImpl(mPsiClass);

    List<PsiMethod> methods = new ArrayList<>();
    List<PsiField> fields = new ArrayList<>();

    //generate PROP_selected if possible.
    if(mHasSelectable) {
        fields.add(createConstantField(mPsiClass, elementFactory, Property.PROP_selected));
    }
    //generate for current properties.
    generateProperties(elementFactory, mProps, methods, fields, false);

    final PsiMethod anchor = methods.get(methods.size() - 1);
    PsiComment doc = null;
    if (mSuperFields != null && !mSuperFields.isEmpty()) {
        doc = elementFactory.createCommentFromText(
                "/* \n================== start methods from super properties =============== \n" +
                        "======================================================================= */",
                null);
        //generate for super properties
        generateProperties(elementFactory, mSuperFields, methods, fields, true);
    }

    JavaCodeStyleManager styleManager = JavaCodeStyleManager.getInstance(project);
    for (PsiField pf : fields) {
        styleManager.shortenClassReferences(pf);
        mPsiClass.add(pf);
    }
    for (PsiMethod psi : methods) {
        styleManager.shortenClassReferences(mPsiClass.addBefore(psi, mPsiClass.getLastChild()));
        if (psi == anchor && doc != null) {
            mPsiClass.addBefore(doc, mPsiClass.getLastChild());
        }
    }
    //extend Poolable.
    TypeInterfaceExtend__Poolable poolable = new TypeInterfaceExtend__Poolable();
    if (!poolable.isSuperClassHas(mPsiClass)) {
        poolable.makeInterfaceExtend(mPsiClass, elementFactory, styleManager);
    }
}
 

private void generateInternal(PsiClass mPsiClass, ClassInfo info) {
    if(mPsiClass.getName() == null){
        Util.log("mPsiClass.getName() == null");
        return;
    }
    final Project project = mPsiClass.getProject();
    //delete if exist
    PsiClass psiClass_pre = JavaPsiFacade.getInstance(project).findClass(getSuperClassAsInterfaceName(mPsiClass),
            GlobalSearchScope.projectScope(project));
    if(psiClass_pre != null && psiClass_pre.isValid()){
        if(!psiClass_pre.isWritable()){
            Util.log("the previous PsiClass (" + psiClass_pre.getQualifiedName() + ") can write. will be ignored.");
            return;
        }
        psiClass_pre.delete();
    }

    final String name = "I" + mPsiClass.getName();
    JavaCodeStyleManager styleManager = JavaCodeStyleManager.getInstance(project);
    PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(project);

    PsiElement parent = mPsiClass.getParent();
    if(parent instanceof PsiClass){
        Util.log("start nested class.");
        PsiClass psic = elementFactory.createInterface(name);
        psic.getModifierList().addAnnotation("com.heaven7.java.data.mediator.Fields(value ={\n"
                + buildFieldAnnotations(info.getPropertyInfos())+ "\n} , generateJsonAdapter = false)");
        if (!addExtendInterfaces(info, styleManager, elementFactory, psic)) {
            return;
        }
        styleManager.shortenClassReferences(parent.addAfter(psic, mPsiClass));
    }else{
        PsiDirectory dir = mPsiClass.getContainingFile().getContainingDirectory();
        PsiClass psiClass = createJavaFile(name, "@com.heaven7.java.data.mediator.Fields(value ={\n"
                                    + buildFieldAnnotations(info.getPropertyInfos())
                + "\n}, generateJsonAdapter = false) "
                + "public interface " + name + "{}");
        if (!addExtendInterfaces(info, styleManager, elementFactory, psiClass)) {
            return;
        }
        styleManager.shortenClassReferences(psiClass);
        dir.add(psiClass);
    }
}
 

private void finish(Project project, PsiFile psiFile) {
  JavaCodeStyleManager.getInstance(project).optimizeImports(psiFile);
  UndoUtil.markPsiFileForUndo(psiFile);
}
 

@Nonnull
@Provides
@Singleton
public JavaCodeStyleManager provideCodeStyleManager(@Nonnull Project project) {
    return JavaCodeStyleManager.getInstance(project);
}
 

@Inject
public ParameterNamePolicy(@Nonnull JavaCodeStyleManager codeStyleManager) {
    this.codeStyleManager = codeStyleManager;
}
 

@Inject
public FieldNamePolicy(@Nonnull JavaCodeStyleManager codeStyleManager) {
    this.codeStyleManager = codeStyleManager;
}
 

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

void makeInterfaceExtend(PsiClass mClass, PsiElementFactory elementFactory, JavaCodeStyleManager styleManager);