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

Convert KotlinSourceFileCollector: actual conversion

Browse Source 
Original commit: 3f36f472b3
This commit is contained in:
Alexey Tsvetkov
2018-04-03 00:57:39 +03:00
parent fbe7dc02f6
commit 4cd2068ebc
1 changed files with 57 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files
jps/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinSourceFileCollector.kt
+57 -104
View File
@@ -14,128 +14,81 @@
* 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.io.FileUtil
import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.io.FileUtilRt
import com.intellij.openapi.util.io.FileUtilRt; import com.intellij.util.Processor
import com.intellij.util.Function; import com.intellij.util.containers.ContainerUtil
import com.intellij.util.Processor; import com.intellij.util.containers.MultiMap
import com.intellij.util.containers.ContainerUtil; import org.jetbrains.jps.builders.DirtyFilesHolder
import com.intellij.util.containers.MultiMap; import org.jetbrains.jps.builders.FileProcessor
import org.jetbrains.annotations.NotNull; import org.jetbrains.jps.builders.java.JavaSourceRootDescriptor
import org.jetbrains.jps.builders.DirtyFilesHolder; import org.jetbrains.jps.incremental.ModuleBuildTarget
import org.jetbrains.jps.builders.FileProcessor; import org.jetbrains.jps.model.java.JavaSourceRootProperties
import org.jetbrains.jps.builders.java.JavaSourceRootDescriptor; import org.jetbrains.jps.model.java.JavaSourceRootType
import org.jetbrains.jps.incremental.ModuleBuildTarget; import org.jetbrains.jps.model.java.JpsJavaExtensionService
import org.jetbrains.jps.model.java.JavaSourceRootType; import org.jetbrains.jps.model.module.JpsModuleSourceRoot
import org.jetbrains.jps.model.java.JpsJavaExtensionService; import org.jetbrains.jps.util.JpsPathUtil
import org.jetbrains.jps.model.java.compiler.JpsCompilerExcludes;
import org.jetbrains.jps.model.module.JpsModuleSourceRoot;
import org.jetbrains.jps.util.JpsPathUtil;
import java.io.File; import java.io.File
import java.io.IOException;
import java.util.List;
public class KotlinSourceFileCollector { object KotlinSourceFileCollector {
// For incremental compilation // For incremental compilation
@NotNull fun getDirtySourceFiles(dirtyFilesHolder: DirtyFilesHolder<JavaSourceRootDescriptor, ModuleBuildTarget>): MultiMap<ModuleBuildTarget, File> {
public static MultiMap<ModuleBuildTarget, File> getDirtySourceFiles(DirtyFilesHolder<JavaSourceRootDescriptor, ModuleBuildTarget> dirtyFilesHolder) val result = MultiMap<ModuleBuildTarget, File>()
throws IOException {
final MultiMap<ModuleBuildTarget, File> result = new MultiMap<ModuleBuildTarget, File>();
dirtyFilesHolder.processDirtyFiles(new FileProcessor<JavaSourceRootDescriptor, ModuleBuildTarget>() { dirtyFilesHolder.processDirtyFiles(FileProcessor { target, file, root ->
@Override //TODO this is a workaround for bug in JPS: the latter erroneously calls process with invalid parameters
public boolean apply(ModuleBuildTarget target, File file, JavaSourceRootDescriptor root) throws IOException { if (root.getTarget() != target) {
//TODO this is a workaround for bug in JPS: the latter erroneously calls process with invalid parameters return@FileProcessor true
if (!root.getTarget().equals(target)) {
return true;
}
if (isKotlinSourceFile(file)) {
result.putValue(target, file);
}
return true;
} }
});
return result; if (isKotlinSourceFile(file)) {
result.putValue(target, file)
}
true
})
return result
} }
@NotNull fun getRemovedKotlinFiles(
public static List<File> getRemovedKotlinFiles( dirtyFilesHolder: DirtyFilesHolder<JavaSourceRootDescriptor, ModuleBuildTarget>,
@NotNull DirtyFilesHolder<JavaSourceRootDescriptor, ModuleBuildTarget> dirtyFilesHolder, target: ModuleBuildTarget
@NotNull ModuleBuildTarget target ): List<File> {
) throws IOException { return ContainerUtil.map(ContainerUtil.filter(dirtyFilesHolder.getRemovedFiles(target)) { s -> FileUtilRt.extensionEquals(s, "kt") }
return ContainerUtil.map(ContainerUtil.filter(dirtyFilesHolder.getRemovedFiles(target), new Condition<String>() { ) { s -> File(s) }
@Override
public boolean value(String s) {
return FileUtilRt.extensionEquals(s, "kt");
}
}),
new Function<String, File>() {
@Override
public File fun(String s) {
return new File(s);
}
});
} }
@NotNull fun getAllKotlinSourceFiles(target: ModuleBuildTarget): List<File> {
public static List<File> getAllKotlinSourceFiles(@NotNull ModuleBuildTarget target) { val moduleExcludes = ContainerUtil.map(target.module.excludeRootsList.urls) { url -> JpsPathUtil.urlToFile(url) }
final List<File> moduleExcludes =
ContainerUtil.map(target.getModule().getExcludeRootsList().getUrls(), new Function<String, File>() {
@Override
public File fun(String url) {
return JpsPathUtil.urlToFile(url);
}
});
final JpsCompilerExcludes compilerExcludes = val compilerExcludes = JpsJavaExtensionService.getInstance().getOrCreateCompilerConfiguration(target.module.project)
JpsJavaExtensionService.getInstance().getOrCreateCompilerConfiguration(target.getModule().getProject()) .compilerExcludes
.getCompilerExcludes();
final List<File> result = ContainerUtil.newArrayList(); val result = ContainerUtil.newArrayList<File>()
for (JpsModuleSourceRoot sourceRoot : getRelevantSourceRoots(target)) { for (sourceRoot in getRelevantSourceRoots(target)) {
FileUtil.processFilesRecursively( FileUtil.processFilesRecursively(
sourceRoot.getFile(), sourceRoot.file,
new Processor<File>() { Processor { file ->
@Override if (compilerExcludes.isExcluded(file)) return@Processor true
public boolean process(File file) {
if (compilerExcludes.isExcluded(file)) return true;
if (file.isFile() && isKotlinSourceFile(file)) { if (file.isFile && isKotlinSourceFile(file)) {
result.add(file); result.add(file)
} }
return true; true
} },
}, Processor { dir -> ContainerUtil.find(moduleExcludes) { exclude -> FileUtil.filesEqual(exclude, dir) } == null })
new Processor<File>() {
@Override
public boolean process(final File dir) {
return ContainerUtil.find(moduleExcludes, new Condition<File>() {
@Override
public boolean value(File exclude) {
return FileUtil.filesEqual(exclude, dir);
}
}) == null;
}
});
} }
return result; return result
} }
public static Iterable<JpsModuleSourceRoot> getRelevantSourceRoots(ModuleBuildTarget target) { fun getRelevantSourceRoots(target: ModuleBuildTarget): Iterable<JpsModuleSourceRoot> {
JavaSourceRootType sourceRootType = target.isTests() ? JavaSourceRootType.TEST_SOURCE : JavaSourceRootType.SOURCE; val sourceRootType = if (target.isTests) JavaSourceRootType.TEST_SOURCE else JavaSourceRootType.SOURCE
return target.module.getSourceRoots<JavaSourceRootProperties>(sourceRootType)
//noinspection unchecked
return (Iterable) target.getModule().getSourceRoots(sourceRootType);
} }
static boolean isKotlinSourceFile(File file) { internal fun isKotlinSourceFile(file: File): Boolean {
return FileUtilRt.extensionEquals(file.getName(), "kt"); return FileUtilRt.extensionEquals(file.name, "kt")
}
private KotlinSourceFileCollector() {
} }
} }