private static Map<String, String> buildClassToSourceMap(
ModuleChunk chunk,
CompileContext context,
Set<String> toCompilePaths,
String moduleOutputPath)
throws IOException {
final Map<String, String> class2Src = new HashMap<String, String>();
for (Module module : chunk.getModules()) {
final String moduleName = module.getName().toLowerCase(Locale.US);
final SourceToOutputMapping srcToOut =
context.getDataManager().getSourceToOutputMap(moduleName, context.isCompilingTests());
for (String src : srcToOut.getKeys()) {
if (!toCompilePaths.contains(src) && isGroovyFile(src)) {
final Collection<String> outs = srcToOut.getState(src);
if (outs != null) {
for (String out : outs) {
if (out.endsWith(".class") && out.startsWith(moduleOutputPath)) {
final String className =
out.substring(moduleOutputPath.length(), out.length() - ".class".length())
.replace('/', '.');
class2Src.put(className, src);
}
}
}
}
}
}
return class2Src;
}
private static String getModuleOutput(CompileContext context, ModuleChunk chunk) {
final Module representativeModule = chunk.getModules().iterator().next();
File moduleOutputDir =
context
.getProjectPaths()
.getModuleOutputDir(representativeModule, context.isCompilingTests());
assert moduleOutputDir != null;
String moduleOutputPath = FileUtil.toCanonicalPath(moduleOutputDir.getPath());
return moduleOutputPath.endsWith("/") ? moduleOutputPath : moduleOutputPath + "/";
}
private static List<String> generateClasspath(CompileContext context, ModuleChunk chunk) {
final Set<String> cp = new LinkedHashSet<String>();
// groovy_rt.jar
// IMPORTANT! must be the first in classpath
cp.add(ClasspathBootstrap.getResourcePath(GroovyCompilerWrapper.class).getPath());
for (File file :
context
.getProjectPaths()
.getClasspathFiles(chunk, ClasspathKind.compile(context.isCompilingTests()), false)) {
cp.add(FileUtil.toCanonicalPath(file.getPath()));
}
for (File file :
context
.getProjectPaths()
.getClasspathFiles(chunk, ClasspathKind.runtime(context.isCompilingTests()), false)) {
cp.add(FileUtil.toCanonicalPath(file.getPath()));
}
return new ArrayList<String>(cp);
}
private boolean updateDependencies(
CompileContext context,
ModuleChunk chunk,
List<File> toCompile,
String moduleOutputPath,
List<GroovycOSProcessHandler.OutputItem> successfullyCompiled)
throws IOException {
final Mappings delta = context.createDelta();
final List<File> successfullyCompiledFiles = new ArrayList<File>();
if (!successfullyCompiled.isEmpty()) {
final Callbacks.Backend callback = delta.getCallback();
final FileGeneratedEvent generatedEvent = new FileGeneratedEvent();
for (GroovycOSProcessHandler.OutputItem item : successfullyCompiled) {
final String sourcePath = FileUtil.toSystemIndependentName(item.sourcePath);
final String outputPath = FileUtil.toSystemIndependentName(item.outputPath);
final RootDescriptor moduleAndRoot = context.getModuleAndRoot(new File(sourcePath));
if (moduleAndRoot != null) {
final String moduleName = moduleAndRoot.module.getName().toLowerCase(Locale.US);
context
.getDataManager()
.getSourceToOutputMap(moduleName, moduleAndRoot.isTestRoot)
.appendData(sourcePath, outputPath);
}
callback.associate(
outputPath,
Callbacks.getDefaultLookup(sourcePath),
new ClassReader(FileUtil.loadFileBytes(new File(outputPath))));
successfullyCompiledFiles.add(new File(sourcePath));
generatedEvent.add(
moduleOutputPath, FileUtil.getRelativePath(moduleOutputPath, outputPath, '/'));
}
context.processMessage(generatedEvent);
}
return updateMappings(context, delta, chunk, toCompile, successfullyCompiledFiles);
}
private static List<File> collectChangedFiles(CompileContext context, ModuleChunk chunk)
throws IOException {
final List<File> toCompile = new ArrayList<File>();
context.processFilesToRecompile(
chunk,
new FileProcessor() {
public boolean apply(Module module, File file, String sourceRoot) throws IOException {
final String path = file.getPath();
if (isGroovyFile(path)) { // todo file type check
toCompile.add(file);
}
return true;
}
});
return toCompile;
}
public ModuleLevelBuilder.ExitCode build(final CompileContext context, ModuleChunk chunk)
throws ProjectBuildException {
try {
final List<File> toCompile = collectChangedFiles(context, chunk);
if (toCompile.isEmpty()) {
return ExitCode.NOTHING_DONE;
}
String moduleOutput = getModuleOutput(context, chunk);
String compilerOutput = getCompilerOutput(moduleOutput);
final Set<String> toCompilePaths = new LinkedHashSet<String>();
for (File file : toCompile) {
toCompilePaths.add(FileUtil.toSystemIndependentName(file.getPath()));
}
Map<String, String> class2Src =
buildClassToSourceMap(chunk, context, toCompilePaths, moduleOutput);
String ideCharset = chunk.getProject().getProjectCharset();
String encoding =
!Comparing.equal(CharsetToolkit.getDefaultSystemCharset().name(), ideCharset)
? ideCharset
: null;
List<String> patchers = Collections.emptyList(); // todo patchers
final File tempFile =
GroovycOSProcessHandler.fillFileWithGroovycParameters(
compilerOutput,
toCompilePaths,
FileUtil.toSystemDependentName(moduleOutput),
class2Src,
encoding,
patchers);
// todo different outputs in a chunk
// todo xmx
final List<String> cmd =
ExternalProcessUtil.buildJavaCommandLine(
getJavaExecutable(chunk),
"org.jetbrains.groovy.compiler.rt.GroovycRunner",
Collections.<String>emptyList(),
new ArrayList<String>(generateClasspath(context, chunk)),
Arrays.asList(
"-Xmx384m",
"-Dfile.encoding=" + CharsetToolkit.getDefaultSystemCharset().name() /*,
"-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5239"*/),
Arrays.<String>asList(myForStubs ? "stubs" : "groovyc", tempFile.getPath()));
final Process process = Runtime.getRuntime().exec(ArrayUtil.toStringArray(cmd));
GroovycOSProcessHandler handler =
GroovycOSProcessHandler.runGroovyc(
process,
new Consumer<String>() {
public void consume(String s) {
context.processMessage(new ProgressMessage(s));
}
});
if (handler.shouldRetry()) {
if (CHUNK_REBUILD_ORDERED.get(context) != null) {
CHUNK_REBUILD_ORDERED.set(context, null);
} else {
CHUNK_REBUILD_ORDERED.set(context, Boolean.TRUE);
return ExitCode.CHUNK_REBUILD_REQUIRED;
}
}
if (myForStubs) {
JavaBuilder.addTempSourcePathRoot(context, new File(compilerOutput));
}
for (CompilerMessage message : handler.getCompilerMessages()) {
context.processMessage(message);
}
if (!myForStubs
&& updateDependencies(
context, chunk, toCompile, moduleOutput, handler.getSuccessfullyCompiled())) {
return ExitCode.ADDITIONAL_PASS_REQUIRED;
}
return ExitCode.OK;
} catch (Exception e) {
throw new ProjectBuildException(e);
}
}
