J2K PathUtil: convert and prettify

Author: udalov

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt

@@ -62,7 +62,7 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
  val paths = if (arguments.kotlinHome != null)
  KotlinPathsFromHomeDir(File(arguments.kotlinHome))
  else
- PathUtil.getKotlinPathsForCompiler()
+ PathUtil.kotlinPathsForCompiler
 
  messageCollector.report(LOGGING, "Using Kotlin home directory ${paths.homePath}")
  PerformanceCounter.setTimeCounterEnabled(arguments.reportPerf)

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt

@@ -477,7 +477,7 @@ class KotlinCoreEnvironment private constructor(
  var pluginRoot =
  configuration.get(CLIConfigurationKeys.INTELLIJ_PLUGIN_ROOT)?.let(::File)
  ?: configuration.get(CLIConfigurationKeys.COMPILER_JAR_LOCATOR)?.compilerJar
- ?: PathUtil.getPathUtilJar()
+ ?: PathUtil.pathUtilJar
 
  val app = ApplicationManager.getApplication()
  val parentFile = pluginRoot.parentFile

compiler/daemon/src/org/jetbrains/kotlin/daemon/KotlinRemoteReplService.kt

@@ -51,7 +51,7 @@ open class KotlinJvmReplService(
 
  protected val configuration = CompilerConfiguration().apply {
  addJvmClasspathRoots(PathUtil.getJdkClassesRootsFromCurrentJre())
- addJvmClasspathRoots(PathUtil.getKotlinPathsForCompiler().let { listOf(it.stdlibPath, it.reflectPath, it.scriptRuntimePath) })
+ addJvmClasspathRoots(PathUtil.kotlinPathsForCompiler.let { listOf(it.stdlibPath, it.reflectPath, it.scriptRuntimePath) })
  addJvmClasspathRoots(templateClasspath)
  put(CommonConfigurationKeys.MODULE_NAME, "kotlin-script")
  languageVersionSettings = LanguageVersionSettingsImpl(

compiler/tests-common/org/jetbrains/kotlin/test/MockLibraryUtil.kt

@@ -214,7 +214,7 @@ object MockLibraryUtil {
  @Synchronized
  private fun createCompilerClassLoader(): ClassLoader {
  return ClassPreloadingUtils.preloadClasses(
- listOf(PathUtil.getKotlinPathsForDistDirectory().compilerPath),
+ listOf(PathUtil.kotlinPathsForDistDirectory.compilerPath),
  Preloader.DEFAULT_CLASS_NUMBER_ESTIMATE, null, null
  )
  }

compiler/tests/org/jetbrains/kotlin/cli/LauncherScriptTest.kt

@@ -20,7 +20,6 @@ import com.intellij.execution.configurations.GeneralCommandLine
 import com.intellij.execution.util.ExecUtil
 import com.intellij.openapi.util.SystemInfo
 import com.intellij.openapi.util.text.StringUtil
-import org.jetbrains.kotlin.cli.common.ExitCode
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TestCaseWithTmpdir
 import org.jetbrains.kotlin.utils.PathUtil
@@ -36,7 +35,7 @@ class LauncherScriptTest : TestCaseWithTmpdir() {
  workDirectory: File? = null
  ) {
  val executableFileName = if (SystemInfo.isWindows) "$executableName.bat" else executableName
- val launcherFile = File(PathUtil.getKotlinPathsForDistDirectory().homePath, "bin/$executableFileName")
+ val launcherFile = File(PathUtil.kotlinPathsForDistDirectory.homePath, "bin/$executableFileName")
  assertTrue("Launcher script not found, run 'ant dist': ${launcherFile.absolutePath}", launcherFile.exists())
 
  val cmd = GeneralCommandLine(launcherFile.absolutePath, *args)

compiler/tests/org/jetbrains/kotlin/scripts/ScriptTemplateTest.kt

@@ -398,7 +398,7 @@ private fun classpathFromClassloader(): List<File> =
 
 open class TestKotlinScriptDependenciesResolver : TestKotlinScriptDummyDependenciesResolver() {
 
- private val kotlinPaths by lazy { PathUtil.getKotlinPathsForCompiler() }
+ private val kotlinPaths by lazy { PathUtil.kotlinPathsForCompiler }
 
  @AcceptedAnnotations(DependsOn::class, DependsOnTwo::class)
  override fun resolve(scriptContents: ScriptContents,

compiler/util/src/org/jetbrains/kotlin/utils/PathUtil.kt

@@ -14,163 +14,144 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.utils;
-
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.application.PathManager;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jps.model.java.impl.JavaSdkUtil;
-
-import java.io.File;
-import java.util.List;
-import java.util.regex.Pattern;
-
-public class PathUtil {
-
- public static final String JPS_KOTLIN_HOME_PROPERTY = "jps.kotlin.home";
-
- public static final String JS_LIB_JAR_NAME = "kotlin-stdlib-js.jar";
- public static final String JS_LIB_10_JAR_NAME = "kotlin-jslib.jar";
- public static final String ALLOPEN_PLUGIN_JAR_NAME = "allopen-compiler-plugin.jar";
- public static final String NOARG_PLUGIN_JAR_NAME = "noarg-compiler-plugin.jar";
- public static final String SAM_WITH_RECEIVER_PLUGIN_JAR_NAME = "sam-with-receiver-compiler-plugin.jar";
- public static final String JS_LIB_SRC_JAR_NAME = "kotlin-stdlib-js-sources.jar";
- public static final String KOTLIN_JAVA_RUNTIME_JAR = "kotlin-runtime.jar";
- public static final String KOTLIN_JAVA_RUNTIME_JRE7_JAR = "kotlin-stdlib-jre7.jar";
- public static final String KOTLIN_JAVA_RUNTIME_JRE8_JAR = "kotlin-stdlib-jre8.jar";
- public static final String KOTLIN_JAVA_RUNTIME_JRE7_SRC_JAR = "kotlin-stdlib-jre7-sources.jar";
- public static final String KOTLIN_JAVA_RUNTIME_JRE8_SRC_JAR = "kotlin-stdlib-jre8-sources.jar";
- public static final String KOTLIN_JAVA_STDLIB_JAR = "kotlin-stdlib.jar";
- public static final String KOTLIN_JAVA_REFLECT_JAR = "kotlin-reflect.jar";
- public static final String KOTLIN_JAVA_SCRIPT_RUNTIME_JAR = "kotlin-script-runtime.jar";
- public static final String KOTLIN_TEST_JAR = "kotlin-test.jar";
- public static final String KOTLIN_TEST_JS_JAR = "kotlin-test-js.jar";
- public static final String KOTLIN_JAVA_STDLIB_SRC_JAR = "kotlin-stdlib-sources.jar";
- public static final String KOTLIN_JAVA_STDLIB_SRC_JAR_OLD = "kotlin-runtime-sources.jar";
- public static final String KOTLIN_REFLECT_SRC_JAR = "kotlin-reflect-sources.jar";
- public static final String KOTLIN_TEST_SRC_JAR = "kotlin-test-sources.jar";
- public static final String KOTLIN_COMPILER_JAR = "kotlin-compiler.jar";
-
- public static final Pattern KOTLIN_RUNTIME_JAR_PATTERN = Pattern.compile("kotlin-(stdlib|runtime)(-\\d[\\d.]+(-.+)?)?\\.jar");
- public static final Pattern KOTLIN_STDLIB_JS_JAR_PATTERN = Pattern.compile("kotlin-stdlib-js.*\\.jar");
- public static final Pattern KOTLIN_JS_LIBRARY_JAR_PATTERN = Pattern.compile("kotlin-js-library.*\\.jar");
-
- public static final String HOME_FOLDER_NAME = "kotlinc";
- private static final File NO_PATH = new File("<no_path>");
-
- private PathUtil() {}
-
- @NotNull
- public static KotlinPaths getKotlinPathsForIdeaPlugin() {
- return ApplicationManager.getApplication().isUnitTestMode()
- ? getKotlinPathsForDistDirectory()
- : new KotlinPathsFromHomeDir(getCompilerPathForIdeaPlugin());
- }
-
- @NotNull
- public static KotlinPaths getKotlinPathsForJpsPlugin() {
- // When JPS is run on TeamCity, it can not rely on Kotlin plugin layout,
- // so the path to Kotlin is specified in a system property
- String jpsKotlinHome = System.getProperty(JPS_KOTLIN_HOME_PROPERTY);
- if (jpsKotlinHome != null) {
- return new KotlinPathsFromHomeDir(new File(jpsKotlinHome));
+package org.jetbrains.kotlin.utils
+
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.application.PathManager
+import org.jetbrains.jps.model.java.impl.JavaSdkUtil
+
+import java.io.File
+import java.util.regex.Pattern
+
+object PathUtil {
+ const val JPS_KOTLIN_HOME_PROPERTY = "jps.kotlin.home"
+
+ const val JS_LIB_JAR_NAME = "kotlin-stdlib-js.jar"
+ const val JS_LIB_10_JAR_NAME = "kotlin-jslib.jar"
+ const val ALLOPEN_PLUGIN_JAR_NAME = "allopen-compiler-plugin.jar"
+ const val NOARG_PLUGIN_JAR_NAME = "noarg-compiler-plugin.jar"
+ const val SAM_WITH_RECEIVER_PLUGIN_JAR_NAME = "sam-with-receiver-compiler-plugin.jar"
+ const val JS_LIB_SRC_JAR_NAME = "kotlin-stdlib-js-sources.jar"
+ const val KOTLIN_JAVA_RUNTIME_JAR = "kotlin-runtime.jar"
+ const val KOTLIN_JAVA_RUNTIME_JRE7_JAR = "kotlin-stdlib-jre7.jar"
+ const val KOTLIN_JAVA_RUNTIME_JRE8_JAR = "kotlin-stdlib-jre8.jar"
+ const val KOTLIN_JAVA_RUNTIME_JRE7_SRC_JAR = "kotlin-stdlib-jre7-sources.jar"
+ const val KOTLIN_JAVA_RUNTIME_JRE8_SRC_JAR = "kotlin-stdlib-jre8-sources.jar"
+ const val KOTLIN_JAVA_STDLIB_JAR = "kotlin-stdlib.jar"
+ const val KOTLIN_JAVA_REFLECT_JAR = "kotlin-reflect.jar"
+ const val KOTLIN_JAVA_SCRIPT_RUNTIME_JAR = "kotlin-script-runtime.jar"
+ const val KOTLIN_TEST_JAR = "kotlin-test.jar"
+ const val KOTLIN_TEST_JS_JAR = "kotlin-test-js.jar"
+ const val KOTLIN_JAVA_STDLIB_SRC_JAR = "kotlin-stdlib-sources.jar"
+ const val KOTLIN_JAVA_STDLIB_SRC_JAR_OLD = "kotlin-runtime-sources.jar"
+ const val KOTLIN_REFLECT_SRC_JAR = "kotlin-reflect-sources.jar"
+ const val KOTLIN_TEST_SRC_JAR = "kotlin-test-sources.jar"
+ const val KOTLIN_COMPILER_JAR = "kotlin-compiler.jar"
+
+ @JvmField
+ val KOTLIN_RUNTIME_JAR_PATTERN: Pattern = Pattern.compile("kotlin-(stdlib|runtime)(-\\d[\\d.]+(-.+)?)?\\.jar")
+ val KOTLIN_STDLIB_JS_JAR_PATTERN: Pattern = Pattern.compile("kotlin-stdlib-js.*\\.jar")
+ val KOTLIN_JS_LIBRARY_JAR_PATTERN: Pattern = Pattern.compile("kotlin-js-library.*\\.jar")
+
+ private const val HOME_FOLDER_NAME = "kotlinc"
+ private val NO_PATH = File("<no_path>")
+
+ @JvmStatic
+ val kotlinPathsForIdeaPlugin: KotlinPaths
+ get() = if (ApplicationManager.getApplication().isUnitTestMode)
+ kotlinPathsForDistDirectory
+ else
+ KotlinPathsFromHomeDir(compilerPathForIdeaPlugin)
+
+ // When JPS is run on TeamCity, it can not rely on Kotlin plugin layout,
+ // so the path to Kotlin is specified in a system property
+ private val kotlinPathsForJpsPlugin: KotlinPaths
+ get() {
+ val jpsKotlinHome = System.getProperty(JPS_KOTLIN_HOME_PROPERTY)
+ return if (jpsKotlinHome != null) {
+ KotlinPathsFromHomeDir(File(jpsKotlinHome))
+ }
+ else KotlinPathsFromHomeDir(compilerPathForJpsPlugin)
  }
- return new KotlinPathsFromHomeDir(getCompilerPathForJpsPlugin());
- }
 
- @NotNull
- public static KotlinPaths getKotlinPathsForJpsPluginOrJpsTests() {
- if ("true".equalsIgnoreCase(System.getProperty("kotlin.jps.tests"))) {
- return getKotlinPathsForDistDirectory();
+ val kotlinPathsForJpsPluginOrJpsTests: KotlinPaths
+ get() = if ("true".equals(System.getProperty("kotlin.jps.tests"), ignoreCase = true)) {
+ kotlinPathsForDistDirectory
  }
- return getKotlinPathsForJpsPlugin();
- }
+ else kotlinPathsForJpsPlugin
 
- @NotNull
- public static KotlinPaths getKotlinPathsForCompiler() {
- if (!getPathUtilJar().isFile()) {
+ @JvmStatic
+ val kotlinPathsForCompiler: KotlinPaths
+ get() = if (!pathUtilJar.isFile) {
  // Not running from a jar, i.e. it is it must be a unit test
- return getKotlinPathsForDistDirectory();
+ kotlinPathsForDistDirectory
  }
- return new KotlinPathsFromHomeDir(getCompilerPathForCompilerJar());
- }
+ else KotlinPathsFromHomeDir(compilerPathForCompilerJar)
 
- @NotNull
- public static KotlinPaths getKotlinPathsForDistDirectory() {
- return new KotlinPathsFromHomeDir(new File("dist", HOME_FOLDER_NAME));
- }
+ @JvmStatic
+ val kotlinPathsForDistDirectory: KotlinPaths
+ get() = KotlinPathsFromHomeDir(File("dist", HOME_FOLDER_NAME))
 
- @NotNull
- private static File getCompilerPathForCompilerJar() {
- File jar = getPathUtilJar();
+ private val compilerPathForCompilerJar: File
+ get() {
+ val jar = pathUtilJar
+ if (!jar.exists()) return NO_PATH
 
- if (!jar.exists()) return NO_PATH;
+ if (jar.name == KOTLIN_COMPILER_JAR) {
+ val lib = jar.parentFile
+ return lib.parentFile
+ }
 
- if (jar.getName().equals(KOTLIN_COMPILER_JAR)) {
- File lib = jar.getParentFile();
- return lib.getParentFile();
+ return NO_PATH
  }
 
- return NO_PATH;
- }
-
- @NotNull
- private static File getCompilerPathForJpsPlugin() {
- File jar = getPathUtilJar();
+ private val compilerPathForJpsPlugin: File
+ get() {
+ val jar = pathUtilJar
+ if (!jar.exists()) return NO_PATH
 
- if (!jar.exists()) return NO_PATH;
+ if (jar.name == "kotlin-jps-plugin.jar") {
+ val pluginHome = jar.parentFile.parentFile.parentFile
+ return File(pluginHome, HOME_FOLDER_NAME)
+ }
 
- if (jar.getName().equals("kotlin-jps-plugin.jar")) {
- File pluginHome = jar.getParentFile().getParentFile().getParentFile();
- return new File(pluginHome, HOME_FOLDER_NAME);
+ return NO_PATH
  }
 
- return NO_PATH;
- }
+ private val compilerPathForIdeaPlugin: File
+ get() {
+ val jar = pathUtilJar
+ if (!jar.exists()) return NO_PATH
 
- @NotNull
- private static File getCompilerPathForIdeaPlugin() {
- File jar = getPathUtilJar();
+  if (jar.name == "kotlin-plugin.jar") {
+  val lib = jar.parentFile
+  val pluginHome = lib.parentFile
 
- if (!jar.exists()) return NO_PATH;
+ return File(pluginHome, HOME_FOLDER_NAME)
+ }
 
- if (jar.getName().equals("kotlin-plugin.jar")) {
- File lib = jar.getParentFile();
- File pluginHome = lib.getParentFile();
-
- return new File(pluginHome, HOME_FOLDER_NAME);
+ return NO_PATH
  }
 
- return NO_PATH;
- }
-
- @NotNull
- public static File getPathUtilJar() {
- return getResourcePathForClass(PathUtil.class);
- }
+ val pathUtilJar: File
+ get() = getResourcePathForClass(PathUtil::class.java)
 
- @NotNull
- public static File getResourcePathForClass(@NotNull Class aClass) {
- String path = "/" + aClass.getName().replace('.', '/') + ".class";
- String resourceRoot = PathManager.getResourceRoot(aClass, path);
- if (resourceRoot == null) {
- throw new IllegalStateException("Resource not found: " + path);
- }
- return new File(resourceRoot).getAbsoluteFile();
+ @JvmStatic
+ fun getResourcePathForClass(aClass: Class<*>): File {
+ val path = "/" + aClass.name.replace('.', '/') + ".class"
+ val resourceRoot = PathManager.getResourceRoot(aClass, path) ?: throw IllegalStateException("Resource not found: $path")
+ return File(resourceRoot).absoluteFile
  }
 
- @NotNull
- public static List<File> getJdkClassesRootsFromCurrentJre() {
- return getJdkClassesRootsFromJre(System.getProperty("java.home"));
- }
+ @JvmStatic
+ fun getJdkClassesRootsFromCurrentJre(): List<File> =
+ getJdkClassesRootsFromJre(System.getProperty("java.home"))
 
- @NotNull
- public static List<File> getJdkClassesRootsFromJre(@NotNull String javaHome) {
- return JavaSdkUtil.getJdkClassesRoots(new File(javaHome), true);
- }
+ @JvmStatic
+ fun getJdkClassesRootsFromJre(javaHome: String): List<File> =
+ JavaSdkUtil.getJdkClassesRoots(File(javaHome), true)
 
- @NotNull
- public static List<File> getJdkClassesRoots(@NotNull File jdkHome) {
- return JavaSdkUtil.getJdkClassesRoots(jdkHome, false);
- }
+ @JvmStatic
+ fun getJdkClassesRoots(jdkHome: File): List<File> =
+ JavaSdkUtil.getJdkClassesRoots(jdkHome, false)
 }

idea/idea-repl/src/org/jetbrains/kotlin/console/KotlinConsoleKeeper.kt

@@ -24,7 +24,6 @@ import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.module.Module
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.projectRoots.JavaSdkType
-import com.intellij.openapi.projectRoots.JdkUtil
 import com.intellij.openapi.projectRoots.SimpleJavaSdkType
 import com.intellij.openapi.roots.ModuleRootManager
 import com.intellij.openapi.roots.OrderEnumerator
@@ -68,7 +67,7 @@ class KotlinConsoleKeeper(val project: Project) {
  // use to debug repl process
  //paramList.add("-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005")
 
- val kotlinPaths = PathUtil.getKotlinPathsForIdeaPlugin()
+ val kotlinPaths = PathUtil.kotlinPathsForIdeaPlugin
  val replClassPath = listOf(kotlinPaths.compilerPath, kotlinPaths.reflectPath, kotlinPaths.stdlibPath, kotlinPaths.scriptRuntimePath)
  .joinToString(File.pathSeparator) { it.absolutePath }
 
@@ -112,4 +111,4 @@ class KotlinConsoleKeeper(val project: Project) {
  companion object {
  @JvmStatic fun getInstance(project: Project) = ServiceManager.getService(project, KotlinConsoleKeeper::class.java)
  }
-}
+}

idea/idea-repl/src/org/jetbrains/kotlin/jsr223/KotlinJsr223JvmScriptEngine4Idea.kt

@@ -44,7 +44,7 @@ class KotlinJsr223JvmScriptEngine4Idea(
 ) : KotlinJsr223JvmScriptEngineBase(factory) {
 
  private val daemon by lazy {
- val path = PathUtil.getKotlinPathsForIdeaPlugin().compilerPath
+ val path = PathUtil.kotlinPathsForIdeaPlugin.compilerPath
  assert(path.exists())
  val compilerId = CompilerId.makeCompilerId(path)
  val daemonOptions = configureDaemonOptions()

idea/idea-repl/src/org/jetbrains/kotlin/jsr223/KotlinJsr223StandardScriptEngineFactory4Idea.kt

@@ -58,7 +58,7 @@ fun classpathFromClassloader(classLoader: ClassLoader): List<File>? =
 private val kotlinCompilerJar: File by lazy {
  // highest prio - explicit property
  System.getProperty("kotlin.compiler.jar")?.let(::File)?.takeIf(File::exists)
- ?: PathUtil.getKotlinPathsForIdeaPlugin().compilerPath
+ ?: PathUtil.kotlinPathsForIdeaPlugin.compilerPath
  ?: throw FileNotFoundException("Cannot find kotlin compiler jar, set kotlin.compiler.jar property to proper location")
 }
 
@@ -83,4 +83,4 @@ private val kotlinScriptRuntimeJar: File? by lazy {
  ?: File(kotlinCompilerJar.parentFile, KOTLIN_JAVA_SCRIPT_RUNTIME_JAR).takeIf(File::exists)
 }
 
-private val kotlinScriptStandardJars by lazy { listOf(kotlinStdlibJar, kotlinScriptRuntimeJar) }
+private val kotlinScriptStandardJars by lazy { listOf(kotlinStdlibJar, kotlinScriptRuntimeJar) }