@NotNull
public static CompilerConfiguration createCompilerConfiguration(
@NotNull CompilerConfiguration base, @NotNull List<Module> chunk, @NotNull File directory) {
CompilerConfiguration configuration = base.copy();
for (Module module : chunk) {
ContentRootsKt.addKotlinSourceRoots(configuration, getAbsolutePaths(directory, module));
}
for (Module module : chunk) {
for (JavaRootPath javaRootPath : module.getJavaSourceRoots()) {
JvmContentRootsKt.addJavaSourceRoot(
configuration, new File(javaRootPath.getPath()), javaRootPath.getPackagePrefix());
}
}
for (Module module : chunk) {
for (String classpathRoot : module.getClasspathRoots()) {
JvmContentRootsKt.addJvmClasspathRoot(configuration, new File(classpathRoot));
}
}
for (Module module : chunk) {
configuration.add(JVMConfigurationKeys.MODULES, module);
}
return configuration;
}
@NotNull
private static List<String> getAbsolutePaths(@NotNull File directory, @NotNull Module module) {
List<String> result = Lists.newArrayList();
for (String sourceFile : module.getSourceFiles()) {
File source = new File(sourceFile);
if (!source.isAbsolute()) {
source = new File(directory, sourceFile);
}
result.add(source.getAbsolutePath());
}
return result;
}
@NotNull
private static GenerationState generate(
@NotNull KotlinCoreEnvironment environment,
@NotNull AnalysisResult result,
@NotNull List<KtFile> sourceFiles,
@Nullable Module module,
File outputDirectory,
String moduleName) {
CompilerConfiguration configuration = environment.getConfiguration();
IncrementalCompilationComponents incrementalCompilationComponents =
configuration.get(JVMConfigurationKeys.INCREMENTAL_COMPILATION_COMPONENTS);
Collection<FqName> packagesWithObsoleteParts;
List<FqName> obsoleteMultifileClasses;
TargetId targetId = null;
if (module == null || incrementalCompilationComponents == null) {
packagesWithObsoleteParts = Collections.emptySet();
obsoleteMultifileClasses = Collections.emptyList();
} else {
targetId = TargetIdKt.TargetId(module);
IncrementalCache incrementalCache =
incrementalCompilationComponents.getIncrementalCache(targetId);
packagesWithObsoleteParts = new HashSet<FqName>();
for (String internalName : incrementalCache.getObsoletePackageParts()) {
packagesWithObsoleteParts.add(JvmClassName.byInternalName(internalName).getPackageFqName());
}
obsoleteMultifileClasses = new ArrayList<FqName>();
for (String obsoleteFacadeInternalName : incrementalCache.getObsoleteMultifileClasses()) {
obsoleteMultifileClasses.add(
JvmClassName.byInternalName(obsoleteFacadeInternalName)
.getFqNameForClassNameWithoutDollars());
}
}
BindingTraceContext diagnosticHolder = new BindingTraceContext();
GenerationState generationState =
new GenerationState(
environment.getProject(),
ClassBuilderFactories.BINARIES,
result.getModuleDescriptor(),
result.getBindingContext(),
sourceFiles,
configuration.get(JVMConfigurationKeys.DISABLE_CALL_ASSERTIONS, false),
configuration.get(JVMConfigurationKeys.DISABLE_PARAM_ASSERTIONS, false),
GenerationState.GenerateClassFilter.GENERATE_ALL,
configuration.get(JVMConfigurationKeys.DISABLE_INLINE, false),
configuration.get(JVMConfigurationKeys.DISABLE_OPTIMIZATION, false),
/* useTypeTableInSerializer = */ false,
diagnosticHolder,
packagesWithObsoleteParts,
obsoleteMultifileClasses,
targetId,
moduleName,
outputDirectory,
incrementalCompilationComponents);
ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();
long generationStart = PerformanceCounter.Companion.currentTime();
KotlinCodegenFacade.compileCorrectFiles(
generationState, CompilationErrorHandler.THROW_EXCEPTION);
long generationNanos = PerformanceCounter.Companion.currentTime() - generationStart;
String desc =
module != null
? "target " + module.getModuleName() + "-" + module.getModuleType() + " "
: "";
String message =
"GENERATE: "
+ sourceFiles.size()
+ " files ("
+ environment.countLinesOfCode(sourceFiles)
+ " lines) "
+ desc
+ "in "
+ TimeUnit.NANOSECONDS.toMillis(generationNanos)
+ " ms";
K2JVMCompiler.Companion.reportPerf(environment.getConfiguration(), message);
ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();
AnalyzerWithCompilerReport.reportDiagnostics(
new FilteredJvmDiagnostics(
diagnosticHolder.getBindingContext().getDiagnostics(),
result.getBindingContext().getDiagnostics()),
environment.getConfiguration().get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY));
ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();
return generationState;
}
public static boolean compileModules(
@NotNull KotlinCoreEnvironment environment,
@NotNull CompilerConfiguration configuration,
@NotNull List<Module> chunk,
@NotNull File directory,
@Nullable File jarPath,
@NotNull List<String> friendPaths,
boolean jarRuntime) {
Map<Module, ClassFileFactory> outputFiles = Maps.newHashMap();
ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();
ModuleVisibilityManager moduleVisibilityManager =
ModuleVisibilityManager.SERVICE.getInstance(environment.getProject());
for (Module module : chunk) {
moduleVisibilityManager.addModule(module);
}
for (String path : friendPaths) {
moduleVisibilityManager.addFriendPath(path);
}
String targetDescription =
"in targets ["
+ Joiner.on(", ")
.join(
Collections2.transform(
chunk,
new Function<Module, String>() {
@Override
public String apply(@Nullable Module input) {
return input != null
? input.getModuleName() + "-" + input.getModuleType()
: "<null>";
}
}))
+ "] ";
AnalysisResult result = analyze(environment, targetDescription);
if (result == null) {
return false;
}
ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();
result.throwIfError();
for (Module module : chunk) {
ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();
List<KtFile> jetFiles =
CompileEnvironmentUtil.getKtFiles(
environment.getProject(),
getAbsolutePaths(directory, module),
new Function1<String, Unit>() {
@Override
public Unit invoke(String s) {
throw new IllegalStateException("Should have been checked before: " + s);
}
});
File moduleOutputDirectory = new File(module.getOutputDirectory());
GenerationState generationState =
generate(
environment, result, jetFiles, module, moduleOutputDirectory, module.getModuleName());
outputFiles.put(module, generationState.getFactory());
}
for (Module module : chunk) {
ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();
writeOutput(
configuration,
outputFiles.get(module),
new File(module.getOutputDirectory()),
jarPath,
jarRuntime,
null);
}
return true;
}