Refactor KotlinPsiFileFactory to KotlinCompiler

Remove workaround for Kotlin Compiler version 1.6 on Java 1.8 (see #1271) which requires KtlintRuleEngine to be injected. The problem of #1271, can still be reproduced with Ktlint 0.43.0 on java 1.8.0_432. With Ktlint 0.44.0 until 1.5.0 which included the workaround, the problem can not be reproduced on that same java version. Without the workaround on that same java version, the problem is also resolved. So, the workaround is no longer needed as it has been resolved in a Kotlin version after 1.6.0.

By removing this workaround, the code is simplified.

Author: paul-dingemans

ktlint-rule-engine/src/main/kotlin/com/pinterest/ktlint/rule/engine/internal/KotlinPsiFileFactory.kt ktlint-rule-engine/src/main/kotlin/com/pinterest/ktlint/rule/engine/internal/KotlinCompiler.kt

@@ -1,7 +1,6 @@
 package com.pinterest.ktlint.rule.engine.internal
 
-import com.pinterest.ktlint.rule.engine.api.KtLintRuleEngine
-import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
+import com.pinterest.ktlint.rule.engine.core.util.cast
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
@@ -14,43 +13,32 @@ import org.jetbrains.kotlin.com.intellij.pom.PomModelAspect
 import org.jetbrains.kotlin.com.intellij.pom.PomTransaction
 import org.jetbrains.kotlin.com.intellij.pom.impl.PomTransactionBase
 import org.jetbrains.kotlin.com.intellij.pom.tree.TreeAspect
+import org.jetbrains.kotlin.com.intellij.psi.PsiFile
 import org.jetbrains.kotlin.com.intellij.psi.PsiFileFactory
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.idea.KotlinLanguage
 import sun.reflect.ReflectionFactory
-import java.nio.file.Files
-import java.nio.file.Path
 import org.jetbrains.kotlin.com.intellij.openapi.diagnostic.Logger as DiagnosticLogger
 
-internal class KotlinPsiFileFactoryProvider {
-    private lateinit var psiFileFactory: PsiFileFactory
+internal object KotlinCompiler {
+    private val psiFileFactory = initPsiFileFactory()
 
-    @Synchronized
-    fun getKotlinPsiFileFactory(ktLintRuleEngine: KtLintRuleEngine): PsiFileFactory =
-        if (::psiFileFactory.isInitialized) {
-            psiFileFactory
-        } else {
-            initPsiFileFactory(ktLintRuleEngine).also { psiFileFactory = it }
-        }
+    fun createFileFromText(
+        psiFileName: String,
+        normalizedText: String,
+    ): PsiFile = psiFileFactory.createFileFromText(psiFileName, KotlinLanguage.INSTANCE, normalizedText)
 }
 
 /**
  * Initialize Kotlin Lexer.
  */
-internal fun initPsiFileFactory(ktLintRuleEngine: KtLintRuleEngine): PsiFileFactory {
+private fun initPsiFileFactory(): PsiFileFactory {
     DiagnosticLogger.setFactory(LoggerFactory::class.java)
 
-    val compilerConfiguration = CompilerConfiguration()
-    compilerConfiguration.put(CommonConfigurationKeys.MESSAGE_COLLECTOR_KEY, MessageCollector.NONE)
-    // Special workaround on JDK 1.8 when KtLint is used from shipped CLI
-    // to prevent Kotlin compiler initialization error
-    if (ktLintRuleEngine.isInvokedFromCli && System.getProperty("java.specification.version") == "1.8") {
-        val extensionPath = extractCompilerExtension()
-        compilerConfiguration.put(
-            CLIConfigurationKeys.INTELLIJ_PLUGIN_ROOT,
-            extensionPath.toAbsolutePath().toString(),
-        )
-    }
+    val compilerConfiguration =
+        CompilerConfiguration()
+            .apply { put(CommonConfigurationKeys.MESSAGE_COLLECTOR_KEY, MessageCollector.NONE) }
 
     val disposable = Disposer.newDisposable()
     try {
@@ -60,8 +48,9 @@ internal fun initPsiFileFactory(ktLintRuleEngine: KtLintRuleEngine): PsiFileFact
                     disposable,
                     compilerConfiguration,
                     EnvironmentConfigFiles.JVM_CONFIG_FILES,
-                ).project as MockProject
-        project.registerFormatPomModel()
+                ).project
+                .cast<MockProject>()
+                .apply { registerFormatPomModel() }
 
         return PsiFileFactory.getInstance(project)
     } finally {
@@ -72,26 +61,6 @@ internal fun initPsiFileFactory(ktLintRuleEngine: KtLintRuleEngine): PsiFileFact
     }
 }
 
-/**
- * Note: this only works in CLI shadowed jar! 'extensions/compiler.xml' is absent in non-shadowed jar.
- */
-private fun extractCompilerExtension(): Path {
-    KtLintRuleEngine::class.java.getResourceAsStream("/META-INF/extensions/compiler.xml").use { input ->
-        val tempDir = Files.createTempDirectory("ktlint")
-        tempDir.toFile().deleteOnExit()
-
-        val extensionsDir =
-            tempDir.resolve("META-INF/extensions").also {
-                Files.createDirectories(it)
-            }
-        extensionsDir.resolve("compiler.xml").toFile().outputStream().buffered().use {
-            input!!.copyTo(it)
-        }
-
-        return tempDir
-    }
-}
-
 /**
  * Do not print anything to the stderr when lexer is unable to match input.
  */

ktlint-rule-engine/src/main/kotlin/com/pinterest/ktlint/rule/engine/internal/RuleExecutionContext.kt

@@ -24,12 +24,8 @@ import org.jetbrains.kotlin.com.intellij.lang.ASTNode
 import org.jetbrains.kotlin.com.intellij.lang.FileASTNode
 import org.jetbrains.kotlin.com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.com.intellij.psi.PsiErrorElement
-import org.jetbrains.kotlin.idea.KotlinLanguage
-import org.jetbrains.kotlin.psi.KtFile
 import kotlin.io.path.pathString
 
-private val KOTLIN_PSI_FILE_FACTORY_PROVIDER = KotlinPsiFileFactoryProvider()
-
 private val LOGGER = KotlinLogging.logger {}.initKtLintKLogger()
 
 internal class RuleExecutionContext private constructor(
@@ -209,7 +205,6 @@ internal class RuleExecutionContext private constructor(
             ktLintRuleEngine: KtLintRuleEngine,
             code: Code,
         ): RuleExecutionContext {
-            val psiFileFactory = KOTLIN_PSI_FILE_FACTORY_PROVIDER.getKotlinPsiFileFactory(ktLintRuleEngine)
             val normalizedText = normalizeText(code.content)
             val positionInTextLocator = buildPositionInTextLocator(normalizedText)
 
@@ -222,20 +217,18 @@ internal class RuleExecutionContext private constructor(
                     } else {
                         "File.kt"
                     }
-            val psiFile =
-                psiFileFactory.createFileFromText(
-                    psiFileName,
-                    KotlinLanguage.INSTANCE,
-                    normalizedText,
-                ) as KtFile
-            psiFile
-                .findErrorElement()
-                ?.let { errorElement ->
-                    val (line, col) = positionInTextLocator(errorElement.textOffset)
-                    throw KtLintParseException(line, col, errorElement.errorDescription)
-                }
-
-            val rootNode = psiFile.node
+            val rootNode =
+                KotlinCompiler
+                    .createFileFromText(psiFileName, normalizedText)
+                    .also {
+                        // Throw exception when PSI contains an error element
+                        it
+                            .findErrorElement()
+                            ?.let { errorElement ->
+                                val (line, col) = positionInTextLocator(errorElement.textOffset)
+                                throw KtLintParseException(line, col, errorElement.errorDescription)
+                            }
+                    }.node
 
             val editorConfig =
                 ktLintRuleEngine