@Override
public VirtualFile[] getSourceRoots(Module module) {
VirtualFile[] cachedRoots = myModuleToRootsCache.get(module);
if (cachedRoots != null) {
if (areFilesValid(cachedRoots)) {
return cachedRoots;
} else {
myModuleToRootsCache.remove(
module); // clear cache for this module and rebuild list of roots
}
}
Set<VirtualFile> additionalRoots = myModuleToRootsMap.get(module);
VirtualFile[] moduleRoots = ModuleRootManager.getInstance(module).getSourceRoots();
if (additionalRoots == null || additionalRoots.isEmpty()) {
myModuleToRootsCache.put(module, moduleRoots);
return moduleRoots;
}
final VirtualFile[] allRoots = new VirtualFile[additionalRoots.size() + moduleRoots.length];
System.arraycopy(moduleRoots, 0, allRoots, 0, moduleRoots.length);
int index = moduleRoots.length;
for (final VirtualFile additionalRoot : additionalRoots) {
allRoots[index++] = additionalRoot;
}
myModuleToRootsCache.put(module, allRoots);
return allRoots;
}
private String getOutputDir(final Module module) {
if (myModuleToOutput.containsKey(module)) {
return myModuleToOutput.get(module);
}
final VirtualFile outputDirectory = myCompileContext.getModuleOutputDirectory(module);
final String out = outputDirectory != null ? outputDirectory.getPath() : null;
myModuleToOutput.put(module, out);
return out;
}
private VirtualFile getTempDir(Module module) throws IOException {
VirtualFile tempDir = myModuleToTempDirMap.get(module);
if (tempDir == null) {
final String projectName = myProject.getName();
final String moduleName = module.getName();
File tempDirectory = FileUtil.createTempDirectory(projectName, moduleName);
tempDir = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(tempDirectory);
if (tempDir == null) {
LOG.error("Cannot locate temp directory " + tempDirectory.getPath());
}
myModuleToTempDirMap.put(module, tempDir);
}
return tempDir;
}
@Override
public Module getModuleByFile(VirtualFile file) {
final Module module = myProjectFileIndex.getModuleForFile(file);
if (module != null) {
LOG.assertTrue(!module.isDisposed());
return module;
}
for (final VirtualFile root : myRootToModuleMap.keySet()) {
if (VfsUtil.isAncestor(root, file, false)) {
final Module mod = myRootToModuleMap.get(root);
if (mod != null) {
LOG.assertTrue(!mod.isDisposed());
}
return mod;
}
}
return null;
}
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);
}
}
}
}
}
}