private static void addStubRootsToJavacSourcePath(
CompileContext context, Map<ModuleBuildTarget, String> generationOutputs) {
final BuildRootIndex rootsIndex = context.getProjectDescriptor().getBuildRootIndex();
for (ModuleBuildTarget target : generationOutputs.keySet()) {
File root = new File(generationOutputs.get(target));
rootsIndex.associateTempRoot(
context,
target,
new JavaSourceRootDescriptor(root, target, true, true, "", Collections.<File>emptySet()));
}
}
@Nullable
public BuildRootDescriptor findRootDescriptor(
final String rootId, final BuildRootIndex rootIndex) {
for (BuildRootDescriptor descriptor : rootIndex.getTargetRoots(this, null)) {
if (descriptor.getRootId().equals(rootId)) {
return descriptor;
}
}
return null;
}
private static void traverseRecursively(
CompileContext context,
final BuildRootDescriptor rd,
final CompilationRound round,
final File file,
@NotNull final Timestamps tsStorage,
final boolean forceDirty,
@Nullable Set<File> currentFiles,
@Nullable FileFilter filter,
@NotNull FSCache fsCache)
throws IOException {
BuildRootIndex rootIndex = context.getProjectDescriptor().getBuildRootIndex();
final File[] children = fsCache.getChildren(file);
if (children != null) { // is directory
if (children.length > 0 && rootIndex.isDirectoryAccepted(file, rd)) {
for (File child : children) {
traverseRecursively(
context, rd, round, child, tsStorage, forceDirty, currentFiles, filter, fsCache);
}
}
} else { // is file
if (rootIndex.isFileAccepted(file, rd) && (filter == null || filter.accept(file))) {
boolean markDirty = forceDirty;
if (!markDirty) {
markDirty = tsStorage.getStamp(file, rd.getTarget()) != FileSystemUtil.lastModified(file);
}
if (markDirty) {
// if it is full project rebuild, all storages are already completely cleared;
// so passing null because there is no need to access the storage to clear non-existing
// data
final Timestamps marker = context.isProjectRebuild() ? null : tsStorage;
context.getProjectDescriptor().fsState.markDirty(context, round, file, rd, marker);
}
if (currentFiles != null) {
currentFiles.add(file);
}
}
}
}
private ExitCode compile(
final CompileContext context,
ModuleChunk chunk,
DirtyFilesHolder<JavaSourceRootDescriptor, ModuleBuildTarget> dirtyFilesHolder,
Collection<File> files,
OutputConsumer outputConsumer)
throws Exception {
ExitCode exitCode = ExitCode.NOTHING_DONE;
final boolean hasSourcesToCompile = !files.isEmpty();
if (!hasSourcesToCompile && !dirtyFilesHolder.hasRemovedFiles()) {
return exitCode;
}
final ProjectDescriptor pd = context.getProjectDescriptor();
JavaBuilderUtil.ensureModuleHasJdk(
chunk.representativeTarget().getModule(), context, BUILDER_NAME);
final Collection<File> classpath =
ProjectPaths.getCompilationClasspath(chunk, false /*context.isProjectRebuild()*/);
final Collection<File> platformCp =
ProjectPaths.getPlatformCompilationClasspath(chunk, false /*context.isProjectRebuild()*/);
// begin compilation round
final DiagnosticSink diagnosticSink = new DiagnosticSink(context);
final Mappings delta = pd.dataManager.getMappings().createDelta();
final Callbacks.Backend mappingsCallback = delta.getCallback();
final OutputFilesSink outputSink =
new OutputFilesSink(context, outputConsumer, mappingsCallback, chunk.getName());
try {
if (hasSourcesToCompile) {
final AtomicReference<String> ref = COMPILER_VERSION_INFO.get(context);
final String versionInfo =
ref.getAndSet(null); // display compiler version info only once per compile session
if (versionInfo != null) {
LOG.info(versionInfo);
context.processMessage(new CompilerMessage("", BuildMessage.Kind.INFO, versionInfo));
}
exitCode = ExitCode.OK;
final Set<File> srcPath = new HashSet<File>();
final BuildRootIndex index = pd.getBuildRootIndex();
for (ModuleBuildTarget target : chunk.getTargets()) {
for (JavaSourceRootDescriptor rd : index.getTempTargetRoots(target, context)) {
srcPath.add(rd.root);
}
}
final String chunkName = chunk.getName();
context.processMessage(new ProgressMessage("Parsing java... [" + chunkName + "]"));
final int filesCount = files.size();
boolean compiledOk = true;
if (filesCount > 0) {
LOG.info(
"Compiling "
+ filesCount
+ " java files; module: "
+ chunkName
+ (chunk.containsTests() ? " (tests)" : ""));
if (LOG.isDebugEnabled()) {
for (File file : files) {
LOG.debug("Compiling " + file.getPath());
}
LOG.debug(" classpath for " + chunkName + ":");
for (File file : classpath) {
LOG.debug(" " + file.getAbsolutePath());
}
LOG.debug(" platform classpath for " + chunkName + ":");
for (File file : platformCp) {
LOG.debug(" " + file.getAbsolutePath());
}
}
compiledOk =
compileJava(
context,
chunk,
files,
classpath,
platformCp,
srcPath,
diagnosticSink,
outputSink);
}
context.checkCanceled();
if (!compiledOk && diagnosticSink.getErrorCount() == 0) {
diagnosticSink.report(
new PlainMessageDiagnostic(
Diagnostic.Kind.ERROR, "Compilation failed: internal java compiler error"));
}
if (!Utils.PROCEED_ON_ERROR_KEY.get(context, Boolean.FALSE)
&& diagnosticSink.getErrorCount() > 0) {
if (!compiledOk) {
diagnosticSink.report(
new PlainMessageDiagnostic(
Diagnostic.Kind.OTHER,
"Errors occurred while compiling module '" + chunkName + "'"));
}
throw new ProjectBuildException(
"Compilation failed: errors: "
+ diagnosticSink.getErrorCount()
+ "; warnings: "
+ diagnosticSink.getWarningCount());
}
}
} finally {
if (JavaBuilderUtil.updateMappings(
context, delta, dirtyFilesHolder, chunk, files, outputSink.getSuccessfullyCompiled())) {
exitCode = ExitCode.ADDITIONAL_PASS_REQUIRED;
}
}
return exitCode;
}