@NotNull
@Override
public ResolveResult[] multiResolve(final boolean incompleteCode) {
    Project project = myElement.getProject();
    final String enumLiteralJavaModelName = myElement.getText().replaceAll("\"","").toupperCase();

    final PsiShortNamesCache psiShortNamesCache = PsiShortNamesCache.getInstance(project);
    final PsiField[] javaEnumLiteralFields = psiShortNamesCache.getFieldsByName(
        enumLiteralJavaModelName,GlobalSearchScope.allScope(project)
    );

    final Set<PsiField> enumFields = stream(javaEnumLiteralFields)
        .filter(literal -> literal.getParent() != null)
        .filter(literal -> literal.getParent() instanceof ClsClassImpl)
        .filter(literal -> ((ClsClassImpl) literal.getParent()).isEnum())
        .collect(Collectors.toSet());

    return PsiElementResolveResult.createResults(enumFields);
}

@NotNull
@Override
public PsiElement getClsFileNavigationElement(PsiJavaFile clsFile) {
  PsiClass[] classes = clsFile.getClasses();
  if (classes.length == 0) return clsFile;

  String sourceFileName = ((ClsClassImpl)classes[0]).getSourceFileName();
  String packageName = clsFile.getPackageName();
  String relativePath = packageName.isEmpty() ? sourceFileName : packageName.replace('.','/') + '/' + sourceFileName;

  ProjectFileIndex index = ProjectFileIndex.SERVICE.getInstance(clsFile.getProject());
  for (OrderEntry orderEntry : index.getorderEntriesForFile(clsFile.getContainingFile().getVirtualFile())) {
    if (!(orderEntry instanceof LibraryOrSdkOrderEntry)) continue;
    for (VirtualFile root : orderEntry.getFiles(OrderRoottype.soURCES)) {
      VirtualFile source = root.findFileByRelativePath(relativePath);
      if (source != null && source.isValid()) {
        PsiFile psiSource = clsFile.getManager().findFile(source);
        if (psiSource instanceof PsiClassOwner) {
          return psiSource;
        }
      }
    }
  }

  return clsFile;
}

@Override
public PsiElement getClsFileNavigationElement(PsiJavaFile clsFile) {
  String packageName = clsFile.getPackageName();
  PsiClass[] classes = clsFile.getClasses();
  if (classes.length == 0) return clsFile;
  String sourceFileName = ((ClsClassImpl)classes[0]).getSourceFileName();
  String relativeFilePath = packageName.isEmpty() ? sourceFileName : packageName.replace('.','/') + '/' + sourceFileName;

  final VirtualFile vFile = clsFile.getContainingFile().getVirtualFile();
  ProjectFileIndex projectFileIndex = ProjectFileIndex.SERVICE.getInstance(clsFile.getProject());
  final List<OrderEntry> orderEntries = projectFileIndex.getorderEntriesForFile(vFile);
  for (OrderEntry orderEntry : orderEntries) {
    VirtualFile[] files = orderEntry.getFiles(OrderRoottype.soURCES);
    for (VirtualFile file : files) {
      VirtualFile source = file.findFileByRelativePath(relativeFilePath);
      if (source != null) {
        PsiFile psiSource = clsFile.getManager().findFile(source);
        if (psiSource instanceof PsiClassOwner) {
          return psiSource;
        }
      }
    }
  }
  return clsFile;
}

private PsiClass findPsiClassByName(String originalQName,@Nullable Consumer<ClsClassImpl> altClsProcessor)
{
    PsiClass psiClass = null;
    // first check alternative jre if any
    Sdk alternativeJre = myDebugProcess.getSession().getAlternativeJre();
    if(alternativeJre != null)
    {
        psiClass = findClass(myDebugProcess.getProject(),originalQName,AlternativeJreClassFinder.getSearchScope(alternativeJre));
        if(psiClass instanceof ClsClassImpl && altClsProcessor != null)
        { //try to find sources
            altClsProcessor.accept((ClsClassImpl) psiClass);
        }
    }

    if(psiClass == null)
    {
        psiClass = findClass(myDebugProcess.getProject(),myDebugProcess.getSearchScope());
    }
    return psiClass;
}

@Nullable
private PsiFile findAlternativeJreSourceFile(ClsClassImpl psiClass)
{
    String sourceFileName = psiClass.getSourceFileName();
    String packageName = ((PsiClassOwner) psiClass.getContainingFile()).getPackageName();
    String relativePath = packageName.isEmpty() ? sourceFileName : packageName.replace('.','/') + '/' + sourceFileName;
    Sdk alternativeJre = myDebugProcess.getSession().getAlternativeJre();

    if(alternativeJre != null)
    {
        for(VirtualFile file : AlternativeJreClassFinder.getSourceRoots(alternativeJre))
        {
            VirtualFile source = file.findFileByRelativePath(relativePath);
            if(source != null && source.isValid())
            {
                PsiFile psiSource = psiClass.getManager().findFile(source);
                if(psiSource instanceof PsiClassOwner)
                {
                    return psiSource;
                }
            }
        }
    }
    return null;
}

private static boolean processCyclicDependence(PsiClass aClass,Set<PsiClass> classes) {
  if (!classes.add(aClass)) {
    return aClass.isInterface() || CommonClassNames.JAVA_LANG_OBJECT.equals(aClass.getQualifiedname());
  }

  if (aClass instanceof ClsClassImpl) return true; //optimization

  for (PsiClass psiClass : aClass.getSupers()) {
    if (!processCyclicDependence(psiClass,classes)) {
      return false;
    }
  }
  return true;
}

@Contract("null -> false")
public static boolean isTrait(@Nullable PsiClass containingClass) {
  return containingClass instanceof GrTypeDeFinition && ((GrTypeDeFinition)containingClass).isTrait()
         || containingClass instanceof ClsClassImpl
            && containingClass.isInterface()
            && AnnotationUtil.isAnnotated(containingClass,"groovy.transform.Trait",false);
}

public static PsiMethod createTraitMethodFromCompiledHelperMethod(final PsiMethod compiledMethod,final ClsClassImpl trait) {
  assert compiledMethod.getParameterList().getParametersCount() > 0;

  final GrLightMethodBuilder result = new GrLightMethodBuilder(compiledMethod.getManager(),compiledMethod.getName());
  result.setoriginInfo("via @Trait");
  result.addModifier(PsiModifier.STATIC);
  for (PsiTypeParameter parameter : compiledMethod.getTypeParameters()) {
    result.getTypeParameterList().addParameter(parameter);
  }

  final PsiTypeVisitor<PsiType> corrector = createCorrector(compiledMethod,trait);

  final PsiParameter[] methodParameters = compiledMethod.getParameterList().getParameters();
  for (int i = 1; i < methodParameters.length; i++) {
    final PsiParameter originalParameter = methodParameters[i];
    final PsiType correctedType = originalParameter.getType().accept(corrector);
    result.addParameter(originalParameter.getName(),correctedType,false);
  }

  for (PsiClasstype type : compiledMethod.getThrowsList().getReferencedTypes()) {
    final PsiType correctedType = type.accept(corrector);
    result.getThrowsList().addReference(correctedType instanceof PsiClasstype ? (PsiClasstype)correctedType : type);
  }

  {
    final PsiType originalType = compiledMethod.getReturnType();
    result.setReturnType(originalType == null ? null : originalType.accept(corrector));
  }

  final PsiClass traitSource = trait.getSourceMirrorClass();
  final PsiMethod sourceMethod = traitSource == null ? null : traitSource.findMethodBySignature(result,false);
  result.setNavigationElement(sourceMethod != null ? sourceMethod : compiledMethod);

  return result;
}

public static Collection<PsiMethod> getCompiledTraitConcreteMethods(@NotNull final ClsClassImpl trait) {
  return CachedValuesManager.getCachedValue(trait,new CachedValueProvider<Collection<PsiMethod>>() {
    @Nullable
    @Override
    public Result<Collection<PsiMethod>> compute() {
      final Collection<PsiMethod> result = ContainerUtil.newArrayList();
      doCollectCompiledTraitMethods(trait,result);
      return Result.create(result,trait);
    }
  });
}

@Nullable
private Result<PsiFile> getSourceFileResult(ClsFileImpl clsFile,VirtualFile root) {
  // This code is adapted from JavaPsiImplementationHelperImpl#getClsFileNavigationElement
  PsiClass[] classes = clsFile.getClasses();
  if (classes.length == 0) {
    return null;
  }

  String sourceFileName = ((ClsClassImpl) classes[0]).getSourceFileName();
  String packageName = clsFile.getPackageName();
  String relativePath =
      packageName.isEmpty()
          ? sourceFileName
          : packageName.replace('.','/') + '/' + sourceFileName;

  VirtualFile source = root.findFileByRelativePath(relativePath);
  if (source != null && source.isValid()) {
    // Since we have an actual source jar tracked down,use that source jar as the modification
    // tracker. This means the result will continue to be cached unless that source jar changes.
    // If we didn't find a source jar,we use a modification tracker that invalidates on every
    // Blaze sync,which is less efficient.
    PsiFile psiSource = clsFile.getManager().findFile(source);
    if (psiSource instanceof PsiClassOwner) {
      return Result.create(psiSource,source);
    }
    return Result.create(null,source);
  }

  return null;
}

private static boolean processCyclicDependence(PsiClass aClass,classes)) {
      return false;
    }
  }
  return true;
}

@Override
public PsiElement getClsFileNavigationElement(PsiJavaFile clsFile)
{
    PsiClass[] classes = clsFile.getClasses();
    if(classes.length == 0)
    {
        return clsFile;
    }

    String sourceFileName = ((ClsClassImpl) classes[0]).getSourceFileName();
    String packageName = clsFile.getPackageName();
    String relativePath = packageName.isEmpty() ? sourceFileName : packageName.replace('.','/') + '/' + sourceFileName;

    ProjectFileIndex index = ProjectFileIndex.SERVICE.getInstance(clsFile.getProject());
    for(OrderEntry orderEntry : index.getorderEntriesForFile(clsFile.getContainingFile().getVirtualFile()))
    {
        if(!(orderEntry instanceof OrderEntryWithTracking))
        {
            continue;
        }
        for(VirtualFile root : orderEntry.getFiles(SourcesOrderRoottype.getInstance()))
        {
            VirtualFile source = root.findFileByRelativePath(relativePath);
            if(source != null && source.isValid())
            {
                PsiFile psiSource = clsFile.getManager().findFile(source);
                if(psiSource instanceof PsiClassOwner)
                {
                    return psiSource;
                }
            }
        }
    }

    return clsFile;
}

public void actionPerformed(AnActionEvent event) {
        String projectPath = StringUtils.EMPTY;
        try {
            //todo need check if need module.
            UserConfigService.loadUserConfig(ProjectHelper.getProjectPath(event));
            projectPath = ProjectHelper.getProjectPath(event);
            Project project = event.getProject();
            Editor editor = event.getData(LangDataKeys.EDITOR);
            PsiFile currentFile = event.getData(LangDataKeys.PSI_FILE);
            CaretModel caretModel = editor.getCaretModel();
            LogicalPosition oldLogicPos = caretModel.getLogicalPosition();
            String text = currentFile.getText();
            List<String> lines = Splitter.on("\n").splitToList(text);
            PojoLine pojo = getCursorLine(lines,oldLogicPos);
            PsiDirectory containingDirectory = currentFile.getContainingDirectory();
//            HintManager.getInstance().showinformationHint(editor,"success");
            String dir = containingDirectory.getVirtualFile().getCanonicalPath() + GenCodeResponseHelper.getPathSplitter() + currentFile.getName();
            AutoCodingRequest request = new AutoCodingRequest();
            request.setRequestType("AutoCoding");
            request.setCodingType("Setter");
            ServerRequestHelper.fillCommonField(request);
            if (pojo != null) {
                request.setPojoName(pojo.getClassName());
                LogicalPosition newStatementPos = new LogicalPosition(pojo.getLineNumber(),pojo.getLinestartPos() + 1);
                LogicalPosition insertPos = new LogicalPosition(pojo.getLineNumber() + 1,0 );
                caretModel.movetoLogicalPosition(newStatementPos);
                PsiElement currentFileElement = event.getData(LangDataKeys.PSI_ELEMENT);
                if (currentFileElement instanceof PsiClassImpl || currentFileElement instanceof ClsClassImpl) {
                    //                    Integer trueOffSet = getoffset(pojo,dir);
                    //                    if(trueOffSet != 0){
                    //                       offset = trueOffSet;
                    //                    }
                    Document document = PsiDocumentManager.getInstance(event.getProject()).getDocument(currentFile);
                    caretModel.movetoLogicalPosition(insertPos);
                    Integer offset = caretModel.getoffset();
                    String insert = insertSetter(project,pojo,document,currentFileElement,offset);
                    request.setInsert(insert);
//                    SettingService.getSetting().setLastInsertPos(offset);
//                    SettingService.getSetting().setLastInsertLength(setter.length());
                }
            }
//            VirtualFileManager.getInstance().syncRefresh();
//            ApplicationManager.getApplication().saveAll();

            caretModel.movetoLogicalPosition(oldLogicPos);
            SendToServerService.post(project,request);
        } catch (Throwable ignored) {
            LOGGER.error("actionPerformed :{}",ignored);
        }finally {
            LoggerWrapper.saveAllLogs(projectPath);
            SettingService.updateLastRunTime();
        }

    }

@Nullable
protected PsiFile createFile(@NotNull Project project,@NotNull VirtualFile file,@NotNull FileType fileType) {
  if (fileType.isBinary() || file.is(VFileProperty.SPECIAL)) {
    return new PsiBinaryFileImpl((PsiManagerImpl)getManager(),this);
  }
  if (!isTooLargeForIntelligence(file)) {
    final PsiFile psiFile = createFile(getBaseLanguage());
    if (psiFile != null) return psiFile;
  }

  if (isTooLargeForContentLoading(file)) {
    return new PsiLargeFileImpl((PsiManagerImpl)getManager(),this);
  }

  return new PsiPlainTextFileImpl(this);
}

@Nullable
protected PsiFile createFile(@NotNull Project project,this);
  }

  return new PsiPlainTextFileImpl(this);
}

@Nullable
protected PsiFile createFile(@Nonnull Project project,@Nonnull VirtualFile file,@Nonnull FileType fileType) {
  if (fileType.isBinary() || file.is(VFileProperty.SPECIAL)) {
    return SingleRootFileViewProvider.isTooLargeForContentLoading(file) ?
           new PsiLargeBinaryFileImpl((PsiManagerImpl)getManager(),this) :
           new PsiBinaryFileImpl((PsiManagerImpl)getManager(),this);
  }
  if (!SingleRootFileViewProvider.isTooLargeForIntelligence(file)) {
    final PsiFile psiFile = createFile(getBaseLanguage());
    if (psiFile != null) return psiFile;
  }

  if (SingleRootFileViewProvider.isTooLargeForContentLoading(file)) {
    return new PsiLargeTextFileImpl(this);
  }

  return new PsiPlainTextFileImpl(this);
}

@Override
protected PsiFile createFile(@NotNull Project project,@NotNull FileType fileType)
{
    FileIndexFacade fileIndex = ServiceManager.getService(project,FileIndexFacade.class);
    if(!fileIndex.isInLibraryClasses(file) && fileIndex.isInSource(file) || fileIndex.isExcludedFile(file))
    {
        return new PsiBinaryFileImpl((PsiManagerImpl) getManager(),this);
    }

    // skip inner,anonymous,missing and corrupted classes
    try
    {
        if(!isInnerClass(file))
        {
            return new ClsFileImpl(this);
        }
    }
    catch(Exception e)
    {
        Logger.getInstance(ClassFileViewProvider.class).debug(file.getPath(),e);
    }

    return null;
}

@requiredWriteAction
@Override
public PsiElement setName(@Nonnull String name) throws IncorrectOperationException {
  checkSetName(name);
  doClearCaches("setName");
  return PsiFileImplUtil.setName(this,name);
}

@Override
public PsiElement setName(@NotNull String name) throws IncorrectOperationException {
  checkSetName(name);
  doClearCaches("setName");
  return PsiFileImplUtil.setName(this,name);
}

@Override
public void checkSetName(String name) throws IncorrectOperationException {
  if (!getViewProvider().isEventSystemEnabled()) return;
  PsiFileImplUtil.checkSetName(this,name);
}

@Override
public void delete() throws IncorrectOperationException {
  checkDelete();
  PsiFileImplUtil.doDelete(this);
}

@Override
public PsiElement setName(@NotNull String name) throws IncorrectOperationException {
  checkSetName(name);
  subtreeChanged();
  return PsiFileImplUtil.setName(this,name);
}

@Override
public void checkSetName(String name) throws IncorrectOperationException {
  if (!getViewProvider().isEventSystemEnabled()) return;
  PsiFileImplUtil.checkSetName(this,name);
}

@Override
public PsiElement setName(@NotNull String name) throws IncorrectOperationException {
  checkSetName(name);
  doClearCaches();
  return PsiFileImplUtil.setName(this,name);
}

@Override
public void checkSetName(String name) throws IncorrectOperationException {
  if (!getViewProvider().isEventSystemEnabled()) return;
  PsiFileImplUtil.checkSetName(this,name);
}

@Override
public void delete() throws IncorrectOperationException {
  checkDelete();
  PsiFileImplUtil.doDelete(this);
}

@Override
public PsiElement setName(@NotNull String name) throws IncorrectOperationException {
  checkSetName(name);
  subtreeChanged();
  return PsiFileImplUtil.setName(this,name);
}

@Override
public void checkSetName(String name) throws IncorrectOperationException {
  if (!getViewProvider().isEventSystemEnabled()) return;
  PsiFileImplUtil.checkSetName(this,name);
}

@Override
public void checkSetName(String name) throws IncorrectOperationException {
  if (!getViewProvider().isEventSystemEnabled()) return;
  PsiFileImplUtil.checkSetName(this,name);
}

@Override
public void delete() throws IncorrectOperationException {
  checkDelete();
  PsiFileImplUtil.doDelete(this);
}

@Override
public PsiElement setName(@Nonnull String name) throws IncorrectOperationException {
  checkSetName(name);
  subtreeChanged();
  return PsiFileImplUtil.setName(this,name);
}

@Override
public void checkSetName(String name) throws IncorrectOperationException {
  if (!getViewProvider().isEventSystemEnabled()) return;
  PsiFileImplUtil.checkSetName(this,name);
}

@Override
public void delete() throws IncorrectOperationException
{
    checkDelete();
    PsiFileImplUtil.doDelete(this);
}

public JavaCoreApplicationEnvironment(disposable parentdisposable) {
  super(parentdisposable);

  registerFileType(JavaClassFileType.INSTANCE,"class");
  registerFileType(JavaFileType.INSTANCE,"java");
  registerFileType(ArchiveFileType.INSTANCE,"jar;zip");

  addExplicitExtension(FileTypeFileViewProviders.INSTANCE,JavaClassFileType.INSTANCE,new ClassFileViewProviderFactory());
  addExplicitExtension(BinaryFileStubBuilders.INSTANCE,new ClassFileStubBuilder());

  addExplicitExtension(LanguageASTFactory.INSTANCE,JavaLanguage.INSTANCE,new CoreJavaASTFactory());
  addExplicitExtension(LanguageParserDeFinitions.INSTANCE,new JavaParserDeFinition());
  addExplicitExtension(LanguageConstantExpressionEvaluator.INSTANCE,new PsiExpressionEvaluator());

  registerExtensionPoint(Extensions.getRootArea(),ClsstubBuilderFactory.EP_NAME,ClsstubBuilderFactory.class);
  registerExtensionPoint(Extensions.getRootArea(),PsiAugmentProvider.EP_NAME,PsiAugmentProvider.class);
  registerExtensionPoint(Extensions.getRootArea(),JavaMainMethodProvider.EP_NAME,JavaMainMethodProvider.class);
  addExtension(ClsstubBuilderFactory.EP_NAME,new DefaultClsstubBuilderFactory());

  myApplication.registerService(PsiPackageImplementationHelper.class,new CorePsiPackageImplementationHelper());

  myApplication.registerService(EmptySubstitutor.class,new EmptySubstitutorImpl());
  myApplication.registerService(JavaDirectoryService.class,createJavaDirectoryService());
  myApplication.registerService(JavaVersionService.class,new JavaVersionService());

  addExplicitExtension(ItemPresentationProviders.INSTANCE,PsiPackage.class,new PackagePresentationProvider());
  addExplicitExtension(ItemPresentationProviders.INSTANCE,PsiClass.class,new ClasspresentationProvider());
  addExplicitExtension(ItemPresentationProviders.INSTANCE,PsiMethod.class,new MethodPresentationProvider());
  addExplicitExtension(ItemPresentationProviders.INSTANCE,PsiField.class,new FieldPresentationProvider());
  addExplicitExtension(ItemPresentationProviders.INSTANCE,PsiLocalVariable.class,new VariablePresentationProvider());
  addExplicitExtension(ItemPresentationProviders.INSTANCE,PsiParameter.class,new VariablePresentationProvider());
}

public JavaCoreApplicationEnvironment(disposable parentdisposable) {
  super(parentdisposable);

  registerFileType(JavaClassFileType.INSTANCE,"java");
  registerFileType(JararchiveFileType.INSTANCE,"jar");

  addExplicitExtension(FileTypeFileViewProviders.INSTANCE,new ClassFileStubBuilder());

  addExplicitExtension(LanguageParserDeFinitions.INSTANCE,JavaMainMethodProvider.class);

  myApplication.registerService(PsiPackageImplementationHelper.class,PsiJavaPackage.class,new VariablePresentationProvider());
}

public JavaCoreApplicationEnvironment(@NotNull disposable parentdisposable) {
  super(parentdisposable);

  registerFileType(JavaClassFileType.INSTANCE,"jar;zip");
  registerFileType(PlainTextFileType.INSTANCE,"txt;sh;bat;cmd;policy;log;cgi;MF;jad;jam;htaccess");

  addExplicitExtension(LanguageASTFactory.INSTANCE,PlainTextLanguage.INSTANCE,new PlainTextASTFactory());
  addExplicitExtension(LanguageParserDeFinitions.INSTANCE,new PlainTextParserDeFinition());

  addExplicitExtension(FileTypeFileViewProviders.INSTANCE,new PsiExpressionEvaluator());

  addExtension(ContainerProvider.EP_NAME,new JavaContainerProvider());

  myApplication.registerService(PsiPackageImplementationHelper.class,new VariablePresentationProvider());

  registerapplicationservice(JavaCodeFoldingSettings.class,new JavaCodeFoldingSettingsBase());
  addExplicitExtension(LanguageFolding.INSTANCE,new JavaFoldingBuilderBase() {
    @Override
    protected boolean shouldShowExplicitLambdaType(PsiAnonymousClass anonymousClass,PsiNewExpression expression) {
      return false;
    }

    @Override
    protected boolean isBelowRightMargin(Project project,int lineLength) {
      return false;
    }
  });

  registerapplicationExtensionPoint(SuperMethodsSearch.EP_NAME,QueryExecutor.class);
  addExtension(SuperMethodsSearch.EP_NAME,new MethodSuperSearcher());
}