@Override public void run(@NotNull final ProgressIndicator indicator) { myIndicator = indicator; final ProjectManager projectManager = ProjectManager.getInstance(); projectManager.addProjectManagerListener(myProject, myCloseListener = new CloseListener()); final Semaphore semaphore = ((CompilerManagerImpl) CompilerManager.getInstance(myProject)).getCompilationSemaphore(); boolean acquired = false; try { try { while (!acquired) { acquired = semaphore.tryAcquire(300, TimeUnit.MILLISECONDS); if (!acquired && !myWaitForPreviousSession) { return; } if (indicator.isCanceled()) { // give up obtaining the semaphore, // let compile work begin in order to stop gracefuly on cancel event break; } } } catch (InterruptedException ignored) { } if (!isHeadless()) { addIndicatorDelegate(); } myCompileWork.run(); } finally { try { indicator.stop(); projectManager.removeProjectManagerListener(myProject, myCloseListener); } finally { if (acquired) { semaphore.release(); } } } }
private static VirtualFile[] getSourceFiles(@NotNull Module module) { return CompilerManager.getInstance(module.getProject()) .createModuleCompileScope(module, false) .getFiles(JetFileType.INSTANCE, true); }
private CompilerManager getCompilerManager() { return CompilerManager.getInstance(myProject); }
public void removeCompilationStatusListener(CompilationStatusListener compilationListener) { CompilerManager.getInstance(project).removeCompilationStatusListener(compilationListener); }
private void buildOutputItemsList( final String outputDir, final Module module, VirtualFile from, final FileTypeManager typeManager, final VirtualFile sourceRoot, final String packagePrefix, final List<File> filesToRefresh, final Map<String, Collection<TranslatingCompiler.OutputItem>> results) throws CacheCorruptedException { final Ref<CacheCorruptedException> exRef = new Ref<CacheCorruptedException>(null); final ModuleFileIndex fileIndex = ModuleRootManager.getInstance(module).getFileIndex(); final GlobalSearchScope srcRootScope = GlobalSearchScope.moduleScope(module) .intersectWith(GlobalSearchScopes.directoryScope(myProject, sourceRoot, true)); final Collection<FileType> registeredInputTypes = CompilerManager.getInstance(myProject).getRegisteredInputTypes(myTranslatingCompiler); final ContentIterator contentIterator = new ContentIterator() { public boolean processFile(final VirtualFile child) { try { if (child.isValid()) { if (!child.isDirectory() && registeredInputTypes.contains(child.getFileType())) { updateOutputItemsList( outputDir, child, sourceRoot, packagePrefix, filesToRefresh, results, srcRootScope); } } return true; } catch (CacheCorruptedException e) { exRef.set(e); return false; } } }; if (fileIndex.isInContent(from)) { // use file index for iteration to handle 'inner modules' and excludes properly fileIndex.iterateContentUnderDirectory(from, contentIterator); } else { // seems to be a root for generated sources VfsUtilCore.visitChildrenRecursively( from, new VirtualFileVisitor() { @Override public boolean visitFile(@NotNull VirtualFile file) { if (!file.isDirectory()) { contentIterator.processFile(file); } return true; } }); } final CacheCorruptedException exc = exRef.get(); if (exc != null) { throw exc; } }
private void runTransformingCompilers(final ModuleChunk chunk) { final JavaSourceTransformingCompiler[] transformers = CompilerManager.getInstance(myProject).getCompilers(JavaSourceTransformingCompiler.class); if (transformers.length == 0) { return; } if (LOG.isDebugEnabled()) { LOG.debug("Running transforming compilers..."); } final Module[] modules = chunk.getModules(); for (final JavaSourceTransformingCompiler transformer : transformers) { final Map<VirtualFile, VirtualFile> originalToCopyFileMap = new HashMap<VirtualFile, VirtualFile>(); final Application application = ApplicationManager.getApplication(); application.invokeAndWait( new Runnable() { public void run() { for (final Module module : modules) { for (final VirtualFile file : chunk.getFilesToCompile(module)) { final VirtualFile untransformed = chunk.getOriginalFile(file); if (transformer.isTransformable(untransformed)) { application.runWriteAction( new Runnable() { public void run() { try { // if untransformed != file, the file is already a (possibly // transformed) copy of the original 'untransformed' file. // If this is the case, just use already created copy and do not copy // file content once again final VirtualFile fileCopy = untransformed.equals(file) ? createFileCopy(getTempDir(module), file) : file; originalToCopyFileMap.put(file, fileCopy); } catch (IOException e) { // skip it } } }); } } } } }, myCompileContext.getProgressIndicator().getModalityState()); // do actual transform for (final Module module : modules) { final List<VirtualFile> filesToCompile = chunk.getFilesToCompile(module); for (int j = 0; j < filesToCompile.size(); j++) { final VirtualFile file = filesToCompile.get(j); final VirtualFile fileCopy = originalToCopyFileMap.get(file); if (fileCopy != null) { final boolean ok = transformer.transform(myCompileContext, fileCopy, chunk.getOriginalFile(file)); if (ok) { chunk.substituteWithTransformedVersion(module, j, fileCopy); } } } } } }