Fix Psi types

Picked from kotlin-community-tools/kotlin-language-server#8

Co-authored-by: Alexandros Alexiou <[email protected]>

Author: fwcd

detekt_baseline.xml

@@ -2,7 +2,7 @@
 <SmellBaseline>
   <ManuallySuppressedIssues></ManuallySuppressedIssues>
   <CurrentIssues>
-    <ID>ComplexCondition:SemanticTokens.kt$element is KtVariableDeclaration &amp;&amp; (!element.isVar() || element.hasModifier(KtTokens.CONST_KEYWORD)) || element is KtParameter</ID>
+    <ID>ComplexCondition:SemanticTokens.kt$element is KtVariableDeclaration &amp;&amp; (!element.isVar || element.hasModifier(KtTokens.CONST_KEYWORD)) || element is KtParameter</ID>
     <ID>CyclomaticComplexMethod:Completions.kt$private fun elementCompletions(file: CompiledFile, cursor: Int, surroundingElement: KtElement): Sequence&lt;DeclarationDescriptor&gt;</ID>
     <ID>CyclomaticComplexMethod:Completions.kt$private fun indexCompletionItems(file: CompiledFile, cursor: Int, element: KtElement?, index: SymbolIndex, partial: String): Sequence&lt;CompletionItem&gt;</ID>
     <ID>CyclomaticComplexMethod:GoToDefinition.kt$fun goToDefinition( file: CompiledFile, cursor: Int, classContentProvider: ClassContentProvider, tempDir: TemporaryDirectory, config: ExternalSourcesConfiguration, cp: CompilerClassPath ): Location?</ID>

server/src/main/kotlin/org/javacs/kt/semantictokens/SemanticTokens.kt

@@ -20,21 +20,16 @@ import org.jetbrains.kotlin.psi.KtFunction
 import org.jetbrains.kotlin.psi.KtModifierListOwner
 import org.jetbrains.kotlin.psi.KtNameReferenceExpression
 import org.jetbrains.kotlin.psi.KtVariableDeclaration
-import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.psi.KtParameter
 import org.jetbrains.kotlin.psi.KtEnumEntry
-import org.jetbrains.kotlin.psi.KtStringTemplateEntry
-import org.jetbrains.kotlin.psi.KtStringTemplateExpression
 import org.jetbrains.kotlin.psi.KtSimpleNameStringTemplateEntry
-import org.jetbrains.kotlin.psi.KtBlockStringTemplateEntry
-import org.jetbrains.kotlin.psi.KtEscapeStringTemplateEntry
 import org.jetbrains.kotlin.resolve.BindingContext
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiNameIdentifierOwner
 import com.intellij.psi.PsiLiteralExpression
-import com.intellij.psi.PsiType
 import com.intellij.openapi.util.TextRange
+import com.intellij.psi.PsiTypes
 
 enum class SemanticTokenType(val typeName: String) {
     KEYWORD(SemanticTokenTypes.Keyword),
@@ -62,8 +57,8 @@ enum class SemanticTokenModifier(val modifierName: String) {
 }
 
 val semanticTokensLegend = SemanticTokensLegend(
-    SemanticTokenType.values().map { it.typeName },
-    SemanticTokenModifier.values().map { it.modifierName }
+    SemanticTokenType.entries.map { it.typeName },
+    SemanticTokenModifier.entries.map { it.modifierName }
 )
 
 data class SemanticToken(val range: Range, val type: SemanticTokenType, val modifiers: Set<SemanticTokenModifier> = setOf())
@@ -119,7 +114,7 @@ private fun elementTokens(element: PsiElement, bindingContext: BindingContext, r
         // TODO: Ideally we would like to cut-off subtrees outside our range, but this doesn't quite seem to work
         // .preOrderTraversal { elem -> textRange?.let { it.contains(elem.textRange) } ?: true }
         .preOrderTraversal()
-        .filter { elem -> textRange?.let { it.contains(elem.textRange) } ?: true }
+        .filter { elem -> textRange?.contains(elem.textRange) ?: true }
         .mapNotNull { elementToken(it, bindingContext) }
 }
 
@@ -129,7 +124,6 @@ private fun elementToken(element: PsiElement, bindingContext: BindingContext): S
 
     return when (element) {
         // References (variables, types, functions, ...)
-
         is KtNameReferenceExpression -> {
             val target = bindingContext[BindingContext.REFERENCE_TARGET, element]
             val tokenType = when (target) {
@@ -158,7 +152,6 @@ private fun elementToken(element: PsiElement, bindingContext: BindingContext): S
         }
 
         // Declarations (variables, types, functions, ...)
-
         is PsiNameIdentifierOwner -> {
             val tokenType = when (element) {
                 is KtParameter -> SemanticTokenType.PARAMETER
@@ -172,7 +165,7 @@ private fun elementToken(element: PsiElement, bindingContext: BindingContext): S
             val identifierRange = element.nameIdentifier?.let { range(file.text, it.textRange) } ?: return null
             val modifiers = mutableSetOf(SemanticTokenModifier.DECLARATION)
 
-            if (element is KtVariableDeclaration && (!element.isVar() || element.hasModifier(KtTokens.CONST_KEYWORD)) || element is KtParameter) {
+            if (element is KtVariableDeclaration && (!element.isVar || element.hasModifier(KtTokens.CONST_KEYWORD)) || element is KtParameter) {
                 modifiers.add(SemanticTokenModifier.READONLY)
             }
 
@@ -186,14 +179,13 @@ private fun elementToken(element: PsiElement, bindingContext: BindingContext): S
         }
 
         // Literals and string interpolations
-
         is KtSimpleNameStringTemplateEntry ->
             SemanticToken(elementRange, SemanticTokenType.INTERPOLATION_ENTRY)
         is PsiLiteralExpression -> {
             val tokenType = when (element.type) {
-                PsiType.INT, PsiType.LONG, PsiType.DOUBLE -> SemanticTokenType.NUMBER
-                PsiType.CHAR -> SemanticTokenType.STRING
-                PsiType.BOOLEAN, PsiType.NULL -> SemanticTokenType.KEYWORD
+                PsiTypes.intType(), PsiTypes.longType(), PsiTypes.doubleType() -> SemanticTokenType.NUMBER
+                PsiTypes.charType() -> SemanticTokenType.STRING
+                PsiTypes.booleanType(), PsiTypes.nullType() -> SemanticTokenType.KEYWORD
                 else -> return null
             }
             SemanticToken(elementRange, tokenType)

server/src/test/kotlin/org/javacs/kt/OneFilePerformance.kt

@@ -1,7 +1,6 @@
 package org.javacs.kt
 
 import org.javacs.kt.util.LoggingMessageCollector
-import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.jvm.compiler.CliBindingTrace
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
@@ -15,7 +14,6 @@ import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmProtoBufUtil
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.resolve.BindingTraceContext
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer
 import org.jetbrains.kotlin.resolve.TopDownAnalysisMode
@@ -33,17 +31,16 @@ import java.nio.charset.StandardCharsets
 class OneFilePerformance {
     @State(Scope.Thread)
     class ReusableParts : Closeable {
-        internal var config = CompilerConfiguration()
+        private var config = CompilerConfiguration()
         init {
             config.put(CommonConfigurationKeys.MODULE_NAME, JvmProtoBufUtil.DEFAULT_MODULE_NAME)
-            config.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, LoggingMessageCollector)
+            config.put(CommonConfigurationKeys.MESSAGE_COLLECTOR_KEY, LoggingMessageCollector)
         }
-        internal val disposable = Disposer.newDisposable()
-        internal var env = KotlinCoreEnvironment.createForProduction(
+        private val disposable = Disposer.newDisposable()
+        private var env = KotlinCoreEnvironment.createForProduction(
             disposable, config, EnvironmentConfigFiles.JVM_CONFIG_FILES
         )
-        internal var parser = KtPsiFactory(env.project)
-        internal var fileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL)
+        private var fileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL)
         internal var bigFile = openFile("/kotlinCompilerPerformance/BigFile.kt")
 
         internal fun openFile(resourcePath: String?): KtFile {

server/src/test/kotlin/org/javacs/kt/OverrideMemberTest.kt

@@ -114,7 +114,7 @@ class OverrideMemberTest : SingleFileTestFixture("overridemember", "OverrideMemb
             "override fun isInterrupted(): Boolean { }",
             "override fun countStackFrames(): Int { }",
             "override fun getContextClassLoader(): ClassLoader { }",
-            "override fun setContextClassLoader(cl: ClassLoader) { }",
+            "override fun setContextClassLoader(p0: ClassLoader) { }",
             "override fun getStackTrace(): (Array<(StackTraceElement..StackTraceElement?)>..Array<out (StackTraceElement..StackTraceElement?)>) { }",
             "override fun getId(): Long { }",
             "override fun getState(): State { }",
@@ -133,7 +133,7 @@ class OverrideMemberTest : SingleFileTestFixture("overridemember", "OverrideMemb
             padding + "override fun isInterrupted(): Boolean { }",
             padding + "override fun countStackFrames(): Int { }",
             padding + "override fun getContextClassLoader(): ClassLoader { }",
-            padding + "override fun setContextClassLoader(cl: ClassLoader) { }",
+            padding + "override fun setContextClassLoader(p0: ClassLoader) { }",
             padding + "override fun getStackTrace(): (Array<(StackTraceElement..StackTraceElement?)>..Array<out (StackTraceElement..StackTraceElement?)>) { }",
             padding + "override fun getId(): Long { }",
             padding + "override fun getState(): State { }",