protected BuildResult doBuild(CompileScopeTestBuilder scope) {
ProjectDescriptor descriptor = createProjectDescriptor(new BuildLoggingManager(myLogger));
try {
myLogger.clear();
return doBuild(descriptor, scope);
} finally {
descriptor.release();
}
}
private void addFilesIncludedInSwc(final Element rootElement) {
final JpsCompilerExcludes excludes =
JpsJavaExtensionService.getInstance()
.getOrCreateCompilerConfiguration(myModule.getProject())
.getCompilerExcludes();
final Map<String, String> filePathToPathInSwc = new THashMap<String, String>();
for (String path : myBC.getCompilerOptions().getFilesToIncludeInSWC()) {
final File fileOrDir = new File(path);
if (excludes.isExcluded(fileOrDir)) continue;
if (myProjectDescriptor.getIgnoredFileIndex().isIgnored(fileOrDir.getName())) continue;
final String baseRelativePath =
StringUtil.notNullize(
FlexCommonUtils.getPathRelativeToSourceRoot(myModule, fileOrDir.getPath()),
fileOrDir.getName());
if (fileOrDir.isDirectory()) {
processFilesRecursively(
fileOrDir,
new Processor<File>() {
public boolean process(final File file) {
if (myProjectDescriptor.getIgnoredFileIndex().isIgnored(file.getName()))
return false;
if (!file.isDirectory()
&& !FlexCommonUtils.isSourceFile(file.getName())
&& !excludes.isExcluded(file)) {
final String relativePath = FileUtil.getRelativePath(fileOrDir, file);
assert relativePath != null;
final String pathInSwc =
baseRelativePath.isEmpty()
? relativePath
: baseRelativePath + "/" + relativePath;
filePathToPathInSwc.put(file.getPath(), pathInSwc);
}
return true;
}
});
} else if (fileOrDir.isFile()) {
filePathToPathInSwc.put(fileOrDir.getPath(), baseRelativePath);
}
}
for (Map.Entry<String, String> entry : filePathToPathInSwc.entrySet()) {
final String value =
FileUtil.toSystemIndependentName(entry.getValue())
+ CompilerOptionInfo.LIST_ENTRY_PARTS_SEPARATOR
+ FileUtil.toSystemIndependentName(entry.getKey());
addOption(rootElement, CompilerOptionInfo.INCLUDE_FILE_INFO, value);
}
}
public static Map<ModuleBuildTarget, Collection<GroovycOutputParser.OutputItem>>
processCompiledFiles(
CompileContext context,
ModuleChunk chunk,
Map<ModuleBuildTarget, String> generationOutputs,
String compilerOutput,
List<GroovycOutputParser.OutputItem> successfullyCompiled)
throws IOException {
ProjectDescriptor pd = context.getProjectDescriptor();
final Map<ModuleBuildTarget, Collection<GroovycOutputParser.OutputItem>> compiled =
new THashMap<ModuleBuildTarget, Collection<GroovycOutputParser.OutputItem>>();
for (final GroovycOutputParser.OutputItem item : successfullyCompiled) {
if (Utils.IS_TEST_MODE || LOG.isDebugEnabled()) {
LOG.info("compiled=" + item);
}
final JavaSourceRootDescriptor rd =
pd.getBuildRootIndex().findJavaRootDescriptor(context, new File(item.sourcePath));
if (rd != null) {
final String outputPath =
ensureCorrectOutput(chunk, item, generationOutputs, compilerOutput, rd.target);
Collection<GroovycOutputParser.OutputItem> items = compiled.get(rd.target);
if (items == null) {
items = new ArrayList<GroovycOutputParser.OutputItem>();
compiled.put(rd.target, items);
}
items.add(new GroovycOutputParser.OutputItem(outputPath, item.sourcePath));
} else {
if (Utils.IS_TEST_MODE || LOG.isDebugEnabled()) {
LOG.info("No java source root descriptor for the item found =" + item);
}
}
}
if (Utils.IS_TEST_MODE || LOG.isDebugEnabled()) {
LOG.info("Chunk " + chunk + " compilation finished");
}
return compiled;
}
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;
}