azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

J2K KotlinBuilderModuleScriptGenerator: convert

Browse Source
This commit is contained in:
Zalim Bashorov
2016-02-03 20:53:21 +03:00
parent d5030335b6
commit 21e69a0a4c
1 changed files with 84 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files
jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilderModuleScriptGenerator.kt
+84 -106
View File
@@ -14,151 +14,129 @@
* limitations under the License. * limitations under the License.
*/ */
package org.jetbrains.kotlin.jps.build; package org.jetbrains.kotlin.jps.build
import com.intellij.openapi.util.Condition; import com.intellij.openapi.util.Condition
import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.io.FileUtil
import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.util.text.StringUtil
import com.intellij.util.containers.ContainerUtil; import com.intellij.util.containers.ContainerUtil
import com.intellij.util.containers.MultiMap; import com.intellij.util.containers.MultiMap
import kotlin.io.FilesKt; import org.jetbrains.jps.ModuleChunk
import org.jetbrains.annotations.NotNull; import org.jetbrains.jps.builders.java.JavaModuleBuildTargetType
import org.jetbrains.annotations.Nullable; import org.jetbrains.jps.incremental.CompileContext
import org.jetbrains.jps.ModuleChunk; import org.jetbrains.jps.incremental.ModuleBuildTarget
import org.jetbrains.jps.builders.BuildTargetType; import org.jetbrains.jps.incremental.ProjectBuildException
import org.jetbrains.jps.builders.java.JavaModuleBuildTargetType; import org.jetbrains.jps.model.java.JpsJavaExtensionService
import org.jetbrains.jps.builders.java.JavaSourceRootDescriptor; import org.jetbrains.kotlin.build.JvmSourceRoot
import org.jetbrains.jps.builders.logging.ProjectBuilderLogger; import org.jetbrains.kotlin.config.IncrementalCompilation
import org.jetbrains.jps.incremental.CompileContext; import org.jetbrains.kotlin.jps.build.JpsUtils.getAllDependencies
import org.jetbrains.jps.incremental.ModuleBuildTarget; import org.jetbrains.kotlin.modules.KotlinModuleXmlBuilder
import org.jetbrains.jps.incremental.ProjectBuildException; import java.io.File
import org.jetbrains.jps.model.java.JpsJavaExtensionService; import java.io.IOException
import org.jetbrains.kotlin.build.JvmSourceRoot; import java.util.*
import org.jetbrains.kotlin.config.IncrementalCompilation;
import org.jetbrains.kotlin.modules.KotlinModuleXmlBuilder;
import java.io.File; object KotlinBuilderModuleScriptGenerator {
import java.io.IOException;
import java.util.*;
import static org.jetbrains.kotlin.jps.build.JpsUtils.getAllDependencies; @Throws(IOException::class, ProjectBuildException::class)
fun generateModuleDescription(
context: CompileContext,
chunk: ModuleChunk,
sourceFiles: MultiMap<ModuleBuildTarget, File>, // ignored for non-incremental compilation
hasRemovedFiles: Boolean): File? {
val builder = KotlinModuleXmlBuilder()
public class KotlinBuilderModuleScriptGenerator { var noSources = true
@Nullable val outputDirs = HashSet<File>()
public static File generateModuleDescription( for (target in chunk.targets) {
CompileContext context, outputDirs.add(getOutputDirSafe(target))
ModuleChunk chunk,
MultiMap<ModuleBuildTarget, File> sourceFiles, // ignored for non-incremental compilation
boolean hasRemovedFiles
) throws IOException, ProjectBuildException {
KotlinModuleXmlBuilder builder = new KotlinModuleXmlBuilder();
boolean noSources = true;
Set<File> outputDirs = new HashSet<File>();
for (ModuleBuildTarget target : chunk.getTargets()) {
outputDirs.add(getOutputDirSafe(target));
} }
ProjectBuilderLogger logger = context.getLoggingManager().getProjectBuilderLogger(); val logger = context.loggingManager.projectBuilderLogger
for (ModuleBuildTarget target : chunk.getTargets()) { for (target in chunk.targets) {
File outputDir = getOutputDirSafe(target); val outputDir = getOutputDirSafe(target)
List<File> friendDirs = new ArrayList<File>(); val friendDirs = ArrayList<File>()
File friendDir = getFriendDirSafe(target); val friendDir = getFriendDirSafe(target)
if (friendDir != null) { if (friendDir != null) {
friendDirs.add(friendDir); friendDirs.add(friendDir)
} }
List<File> moduleSources = new ArrayList<File>( val moduleSources = ArrayList(
IncrementalCompilation.isEnabled() if (IncrementalCompilation.isEnabled())
? sourceFiles.get(target) sourceFiles.get(target)
: KotlinSourceFileCollector.getAllKotlinSourceFiles(target)); else
KotlinSourceFileCollector.getAllKotlinSourceFiles(target))
if (moduleSources.size() > 0 || hasRemovedFiles) { if (moduleSources.size > 0 || hasRemovedFiles) {
noSources = false; noSources = false
if (logger.isEnabled()) { if (logger.isEnabled) {
logger.logCompiledFiles(moduleSources, KotlinBuilder.KOTLIN_BUILDER_NAME, "Compiling files:"); logger.logCompiledFiles(moduleSources, KotlinBuilder.KOTLIN_BUILDER_NAME, "Compiling files:")
} }
} }
BuildTargetType<?> targetType = target.getTargetType(); val targetType = target.targetType
assert targetType instanceof JavaModuleBuildTargetType; assert(targetType is JavaModuleBuildTargetType)
builder.addModule( builder.addModule(
target.getId(), target.id,
outputDir.getAbsolutePath(), outputDir.absolutePath,
moduleSources, moduleSources,
findSourceRoots(context, target), findSourceRoots(context, target),
findClassPathRoots(target), findClassPathRoots(target),
((JavaModuleBuildTargetType) targetType).getTypeId(), (targetType as JavaModuleBuildTargetType).typeId,
((JavaModuleBuildTargetType) targetType).isTests(), targetType.isTests,
// this excludes the output directories from the class path, to be removed for true incremental compilation // this excludes the output directories from the class path, to be removed for true incremental compilation
outputDirs, outputDirs,
friendDirs friendDirs)
);
} }
if (noSources) return null; if (noSources) return null
File scriptFile = File.createTempFile("kjps", StringUtil.sanitizeJavaIdentifier(chunk.getName()) + ".script.xml"); val scriptFile = File.createTempFile("kjps", StringUtil.sanitizeJavaIdentifier(chunk.name) + ".script.xml")
FileUtil.writeToFile(scriptFile, builder.asText().toString()); FileUtil.writeToFile(scriptFile, builder.asText().toString())
return scriptFile; return scriptFile
} }
@NotNull @Throws(ProjectBuildException::class)
public static File getOutputDirSafe(@NotNull ModuleBuildTarget target) throws ProjectBuildException { fun getOutputDirSafe(target: ModuleBuildTarget): File {
File outputDir = target.getOutputDir(); val outputDir = target.outputDir ?: throw ProjectBuildException("No output directory found for " + target)
if (outputDir == null) { return outputDir
throw new ProjectBuildException("No output directory found for " + target);
}
return outputDir;
} }
@Nullable @Throws(ProjectBuildException::class)
private static File getFriendDirSafe(@NotNull ModuleBuildTarget target) throws ProjectBuildException { private fun getFriendDirSafe(target: ModuleBuildTarget): File? {
if (!target.isTests()) return null; if (!target.isTests) return null
File outputDirForProduction = JpsJavaExtensionService.getInstance().getOutputDirectory(target.getModule(), false); val outputDirForProduction = JpsJavaExtensionService.getInstance().getOutputDirectory(target.module, false) ?: return null
if (outputDirForProduction == null) { return outputDirForProduction
return null;
}
return outputDirForProduction;
} }
@NotNull private fun findClassPathRoots(target: ModuleBuildTarget): Collection<File> {
private static Collection<File> findClassPathRoots(@NotNull ModuleBuildTarget target) { return ContainerUtil.filter(getAllDependencies(target).classes().roots, Condition<java.io.File> { file ->
return ContainerUtil.filter(getAllDependencies(target).classes().getRoots(), new Condition<File>() { if (!file.exists()) {
@Override val extension = file.extension
public boolean value(File file) {
if (!file.exists()) {
String extension = FilesKt.getExtension(file);
// Don't filter out files, we want to report warnings about absence through the common place // Don't filter out files, we want to report warnings about absence through the common place
if (!(extension.equals("class") || extension.equals("jar"))) { if (!(extension == "class" || extension == "jar")) {
return false; return@Condition false
}
} }
return true;
} }
});
true
})
} }
@NotNull private fun findSourceRoots(context: CompileContext, target: ModuleBuildTarget): List<JvmSourceRoot> {
private static List<JvmSourceRoot> findSourceRoots(@NotNull CompileContext context, @NotNull ModuleBuildTarget target) { val roots = context.projectDescriptor.buildRootIndex.getTargetRoots(target, context)
List<JavaSourceRootDescriptor> roots = context.getProjectDescriptor().getBuildRootIndex().getTargetRoots(target, context); val result = ContainerUtil.newArrayList<JvmSourceRoot>()
List<JvmSourceRoot> result = ContainerUtil.newArrayList(); for (root in roots) {
for (JavaSourceRootDescriptor root : roots) { val file = root.rootFile
File file = root.getRootFile(); val prefix = root.packagePrefix
String prefix = root.getPackagePrefix();
if (file.exists()) { if (file.exists()) {
result.add(new JvmSourceRoot(file, prefix.isEmpty() ? null : prefix)); result.add(JvmSourceRoot(file, if (prefix.isEmpty()) null else prefix))
} }
} }
return result; return result
} }
private KotlinBuilderModuleScriptGenerator() {}
} }