private boolean compileJava(
final CompileContext context,
ModuleChunk chunk,
Collection<File> files,
Collection<File> classpath,
Collection<File> platformCp,
Collection<File> sourcePath,
DiagnosticOutputConsumer diagnosticSink,
final OutputFileConsumer outputSink)
throws Exception {
final TasksCounter counter = new TasksCounter();
COUNTER_KEY.set(context, counter);
final JpsJavaExtensionService javaExt = JpsJavaExtensionService.getInstance();
final JpsJavaCompilerConfiguration compilerConfig =
javaExt.getCompilerConfiguration(context.getProjectDescriptor().getProject());
assert compilerConfig != null;
final Set<JpsModule> modules = chunk.getModules();
ProcessorConfigProfile profile = null;
if (modules.size() == 1) {
final JpsModule module = modules.iterator().next();
profile = compilerConfig.getAnnotationProcessingProfile(module);
} else {
// perform cycle-related validations
Pair<String, LanguageLevel> pair = null;
for (JpsModule module : modules) {
final LanguageLevel moduleLevel = javaExt.getLanguageLevel(module);
if (pair == null) {
pair = Pair.create(module.getName(), moduleLevel); // first value
} else {
if (!Comparing.equal(pair.getSecond(), moduleLevel)) {
final String message =
"Modules "
+ pair.getFirst()
+ " and "
+ module.getName()
+ " must have the same language level because of cyclic dependencies between them";
diagnosticSink.report(new PlainMessageDiagnostic(Diagnostic.Kind.ERROR, message));
return true;
}
}
}
// check that all chunk modules are excluded from annotation processing
for (JpsModule module : modules) {
final ProcessorConfigProfile prof = compilerConfig.getAnnotationProcessingProfile(module);
if (prof.isEnabled()) {
final String message =
"Annotation processing is not supported for module cycles. Please ensure that all modules from cycle ["
+ chunk.getName()
+ "] are excluded from annotation processing";
diagnosticSink.report(new PlainMessageDiagnostic(Diagnostic.Kind.ERROR, message));
return true;
}
}
}
final Map<File, Set<File>> outs = buildOutputDirectoriesMap(context, chunk);
final List<String> options = getCompilationOptions(context, chunk, profile);
final ClassProcessingConsumer classesConsumer =
new ClassProcessingConsumer(context, outputSink);
if (LOG.isDebugEnabled()) {
LOG.debug(
"Compiling chunk ["
+ chunk.getName()
+ "] with options: \""
+ StringUtil.join(options, " ")
+ "\"");
}
try {
final boolean rc;
if (USE_EMBEDDED_JAVAC) {
final boolean useEclipse = useEclipseCompiler(context);
rc =
JavacMain.compile(
options,
files,
classpath,
platformCp,
sourcePath,
outs,
diagnosticSink,
classesConsumer,
context.getCancelStatus(),
useEclipse);
} else {
final JavacServerClient client = ensureJavacServerLaunched(context);
final RequestFuture<JavacServerResponseHandler> future =
client.sendCompileRequest(
options,
files,
classpath,
platformCp,
sourcePath,
outs,
diagnosticSink,
classesConsumer);
while (!future.waitFor(100L, TimeUnit.MILLISECONDS)) {
if (context.getCancelStatus().isCanceled()) {
future.cancel(false);
}
}
rc = future.getMessageHandler().isTerminatedSuccessfully();
}
return rc;
} finally {
counter.await();
}
}
@Override
public ExitCode build(
final CompileContext context,
ModuleChunk chunk,
DirtyFilesHolder<JavaSourceRootDescriptor, ModuleBuildTarget> dirtyFilesHolder,
OutputConsumer outputConsumer)
throws ProjectBuildException, IOException {
if (!useGreclipse(context)) return ModuleLevelBuilder.ExitCode.NOTHING_DONE;
try {
final List<File> toCompile =
GroovyBuilder.collectChangedFiles(
context, dirtyFilesHolder, false, true, Ref.create(false));
if (toCompile.isEmpty()) {
return ExitCode.NOTHING_DONE;
}
Map<ModuleBuildTarget, String> outputDirs =
GroovyBuilder.getCanonicalModuleOutputs(context, chunk, this);
if (outputDirs == null) {
return ExitCode.ABORT;
}
JpsProject project = context.getProjectDescriptor().getProject();
GreclipseSettings greclipseSettings = GreclipseJpsCompilerSettings.getSettings(project);
if (greclipseSettings == null) {
String message = "Compiler settings component not initialized for " + project;
LOG.error(message);
context.processMessage(
new CompilerMessage(getPresentableName(), BuildMessage.Kind.ERROR, message));
return ExitCode.ABORT;
}
ClassLoader loader = createGreclipseLoader(greclipseSettings.greclipsePath);
if (loader == null) {
context.processMessage(
new CompilerMessage(
getPresentableName(),
BuildMessage.Kind.ERROR,
"Invalid jar path in the compiler settings: '"
+ greclipseSettings.greclipsePath
+ "'"));
return ExitCode.ABORT;
}
final JpsJavaExtensionService javaExt = JpsJavaExtensionService.getInstance();
final JpsJavaCompilerConfiguration compilerConfig = javaExt.getCompilerConfiguration(project);
assert compilerConfig != null;
final Set<JpsModule> modules = chunk.getModules();
ProcessorConfigProfile profile = null;
if (modules.size() == 1) {
profile = compilerConfig.getAnnotationProcessingProfile(modules.iterator().next());
} else {
String message = JavaBuilder.validateCycle(chunk, javaExt, compilerConfig, modules);
if (message != null) {
context.processMessage(
new CompilerMessage(getPresentableName(), BuildMessage.Kind.ERROR, message));
return ExitCode.ABORT;
}
}
String mainOutputDir = outputDirs.get(chunk.representativeTarget());
final List<String> args =
createCommandLine(context, chunk, toCompile, mainOutputDir, profile, greclipseSettings);
if (Utils.IS_TEST_MODE || LOG.isDebugEnabled()) {
LOG.debug("Compiling with args: " + args);
}
Boolean notified = COMPILER_VERSION_INFO.get(context);
if (notified != Boolean.TRUE) {
context.processMessage(
new CompilerMessage(
"",
BuildMessage.Kind.INFO,
"Using Groovy-Eclipse to compile Java & Groovy sources"));
COMPILER_VERSION_INFO.set(context, Boolean.TRUE);
}
context.processMessage(
new ProgressMessage("Compiling java & groovy [" + chunk.getPresentableShortName() + "]"));
StringWriter out = new StringWriter();
StringWriter err = new StringWriter();
HashMap<String, List<String>> outputMap = ContainerUtil.newHashMap();
boolean success = performCompilation(args, out, err, outputMap, context, chunk);
List<GroovycOutputParser.OutputItem> items = ContainerUtil.newArrayList();
for (String src : outputMap.keySet()) {
//noinspection ConstantConditions
for (String classFile : outputMap.get(src)) {
items.add(
new GroovycOutputParser.OutputItem(
FileUtil.toSystemIndependentName(mainOutputDir + classFile),
FileUtil.toSystemIndependentName(src)));
}
}
Map<ModuleBuildTarget, Collection<GroovycOutputParser.OutputItem>> successfullyCompiled =
GroovyBuilder.processCompiledFiles(context, chunk, outputDirs, mainOutputDir, items);
EclipseOutputParser parser = new EclipseOutputParser(getPresentableName(), chunk);
List<CompilerMessage> messages =
ContainerUtil.concat(
parser.parseMessages(out.toString()), parser.parseMessages(err.toString()));
boolean hasError = false;
for (CompilerMessage message : messages) {
if (message.getKind() == BuildMessage.Kind.ERROR) {
hasError = true;
}
context.processMessage(message);
}
if (!success && !hasError) {
context.processMessage(
new CompilerMessage(
getPresentableName(), BuildMessage.Kind.ERROR, "Compilation failed"));
}
GroovyBuilder.updateDependencies(
context, toCompile, successfullyCompiled, outputConsumer, this);
return ExitCode.OK;
} catch (Exception e) {
throw new ProjectBuildException(e);
}
}