[psi] add test on API dump consistency

^KT-78613

Author: dimonchik0036

analysis/analysis-api/build.gradle.kts

@@ -28,6 +28,7 @@ dependencies {
     testApi(platform(libs.junit.bom))
     testImplementation(libs.junit.jupiter.api)
     testRuntimeOnly(libs.junit.jupiter.engine)
+    testImplementation(projectTests(":compiler:psi:psi-api"))
 }
 
 kotlin {

analysis/analysis-api/tests/org/jetbrains/kotlin/analysis/api/test/AnalysisApiSurfaceTest.kt

@@ -1,47 +1,19 @@
 /*
- * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2025 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
 package org.jetbrains.kotlin.analysis.api.test
 
+import org.jetbrains.kotlin.AbstractSurfaceTest
 import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.fail
 import java.nio.file.Paths
-import java.util.function.Consumer
-import kotlin.io.path.readText
 
-class AnalysisApiSurfaceTest {
+class AnalysisApiSurfaceTest : AbstractSurfaceTest() {
     private companion object {
         private val API_SURFACE_PATH = Paths.get("analysis/analysis-api/api/analysis-api.api")
     }
 
     @Test
-    fun testNestedClassCoverage() = runTest {
-        val text = API_SURFACE_PATH.readText()
-        val classNames = Regex("class ([\\w/$]+)\\s*[{:]")
-            .findAll(text)
-            .map { it.groupValues[1] }
-            .toSet()
-
-        for (className in classNames) {
-            val containingClassNames = generateSequence(className) {
-                it.substringBeforeLast('$', missingDelimiterValue = "").takeUnless { it.isEmpty() }
-            }
-
-            for (containingClassName in containingClassNames) {
-                if (containingClassName !in classNames) {
-                    accept("Containing class $containingClassName for $className is missing")
-                }
-            }
-        }
-    }
-
-    private fun runTest(block: Consumer<String>.() -> Unit) {
-        val result = mutableListOf<String>()
-        block(result::add)
-        if (result.isNotEmpty()) {
-            fail("Problems are found:\n" + result.joinToString("\n"))
-        }
-    }
-}
+    fun testNestedClassCoverage() = validateApiDump(API_SURFACE_PATH)
+}

analysis/build.gradle.kts

@@ -19,6 +19,7 @@ tasks.register("analysisAllTests") {
         ":analysis:symbol-light-classes:test",
         ":analysis:analysis-tools:analysis-api-kdoc-coverage-test:test",
         ":compiler:psi:psi-api:apiCheck",
+        ":compiler:psi:psi-api:test",
     )
 
     if (kotlinBuildProperties.isKotlinNativeEnabled) {

compiler/psi/psi-api/api/psi-api.api

@@ -1,7 +1,3 @@
-public final class org/jetbrains/kotlin/KotlinElementTypeProvider$Companion {
-	public final fun getInstance ()Lorg/jetbrains/kotlin/KotlinElementTypeProvider;
-}
-
 public class org/jetbrains/kotlin/KtNodeType : com/intellij/psi/tree/IElementType {
 	public fun <init> (Ljava/lang/String;Ljava/lang/Class;)V
 	public fun createPsi (Lcom/intellij/lang/ASTNode;)Lorg/jetbrains/kotlin/psi/KtElement;

compiler/psi/psi-api/build.gradle.kts

@@ -13,15 +13,26 @@ dependencies {
     compileOnly(intellijCore())
     compileOnly(libs.guava)
     compileOnly(libs.intellij.fastutil)
+
+    testApi(platform(libs.junit.bom))
+    testImplementation(libs.junit.jupiter.api)
+    testRuntimeOnly(libs.junit.jupiter.engine)
 }
 
 sourceSets {
     "main" { projectDefault() }
-    "test" {}
+    "test" { projectDefault() }
 }
 
 apiValidation {
     nonPublicMarkers += listOf(
         "org.jetbrains.kotlin.psi.KtImplementationDetail",
     )
 }
+
+testsJar()
+
+projectTest(jUnitMode = JUnitMode.JUnit5) {
+    workingDir = rootDir
+    useJUnitPlatform()
+}

compiler/psi/psi-api/src/org/jetbrains/kotlin/KotlinElementTypeProvider.kt

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementType
 
 @KtImplementationDetail
 interface KotlinElementTypeProvider {
+    @KtImplementationDetail
     companion object {
         private const val IMPL = "org.jetbrains.kotlin.psi.impl.KotlinElementTypeProviderImpl"
 

compiler/psi/psi-api/tests/org/jetbrains/kotlin/AbstractSurfaceTest.kt

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2010-2025 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin
+
+import org.junit.jupiter.api.fail
+import java.nio.file.Path
+import java.util.function.Consumer
+import kotlin.io.path.readText
+
+abstract class AbstractSurfaceTest {
+    private companion object {
+        private val CLASS_NAME_REGEX = Regex("class ([\\w/$]+)\\s*[{:]")
+    }
+
+    protected fun validateApiDump(apiDumpPath: Path): Unit = runTest {
+        val text = apiDumpPath.readText()
+        val classNames = CLASS_NAME_REGEX
+            .findAll(text)
+            .map { it.groupValues[1] }
+            .toSet()
+
+        for (className in classNames) {
+            val containingClassNames = generateSequence(className) {
+                it.substringBeforeLast('$', missingDelimiterValue = "").takeUnless { it.isEmpty() }
+            }
+
+            for (containingClassName in containingClassNames) {
+                if (containingClassName !in classNames) {
+                    accept("Containing class $containingClassName for $className is missing")
+                }
+            }
+        }
+    }
+
+    private fun runTest(block: Consumer<String>.() -> Unit) {
+        val result = mutableListOf<String>()
+        block(result::add)
+        if (result.isNotEmpty()) {
+            fail("Problems are found:\n" + result.joinToString("\n"))
+        }
+    }
+}

compiler/psi/psi-api/tests/org/jetbrains/kotlin/psi/PsiSurfaceTest.kt

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2010-2025 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.psi
+
+import org.jetbrains.kotlin.AbstractSurfaceTest
+import org.junit.jupiter.api.Test
+import java.nio.file.Paths
+
+class PsiSurfaceTest : AbstractSurfaceTest() {
+    private companion object {
+        private val API_SURFACE_PATH = Paths.get("compiler/psi/psi-api/api/psi-api.api")
+    }
+
+    @Test
+    fun testNestedClassCoverage() = validateApiDump(API_SURFACE_PATH)
+}