FIR: Extract Java class rendering in tests

compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt

@@ -24,17 +24,9 @@ import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
 import org.jetbrains.kotlin.fir.FirRenderer
 import org.jetbrains.kotlin.fir.createSession
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
-import org.jetbrains.kotlin.fir.java.declarations.FirJavaConstructor
-import org.jetbrains.kotlin.fir.java.declarations.FirJavaField
-import org.jetbrains.kotlin.fir.java.declarations.FirJavaMethod
-import org.jetbrains.kotlin.fir.java.scopes.JavaClassEnhancementScope
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.buildUseSiteMemberScope
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCompositeSymbolProvider
-import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -173,56 +165,7 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() {
             val processedJavaClasses = mutableSetOf<FirJavaClass>()
             for (javaClass in javaProvider.getJavaTopLevelClasses().sortedBy { it.name }) {
                 if (javaClass !is FirJavaClass || javaClass in processedJavaClasses) continue
-                val enhancementScope = javaClass.buildUseSiteMemberScope(session, ScopeSession()).let {
+                renderJavaClass(renderer, javaClass, session)
-                    when (it) {
-                        is FirCompositeScope -> it.scopes.filterIsInstance<JavaClassEnhancementScope>().first()
-                        is JavaClassEnhancementScope -> it
-                        else -> null
-                    }
-                }
-                if (enhancementScope == null) {
-                    javaClass.accept(renderer, null)
-                } else {
-                    renderer.visitMemberDeclaration(javaClass)
-                    renderer.renderSupertypes(javaClass)
-                    renderer.renderInBraces {
-                        val renderedDeclarations = mutableListOf<FirDeclaration>()
-                        for (declaration in javaClass.declarations) {
-                            if (declaration in renderedDeclarations) continue
-                            when (declaration) {
-                                is FirJavaConstructor -> enhancementScope.processDeclaredConstructors { symbol ->
-                                    val enhanced = symbol.fir
-                                    if (enhanced !in renderedDeclarations) {
-                                        enhanced.accept(renderer, null)
-                                        renderer.newLine()
-                                        renderedDeclarations += enhanced
-                                    }
-                                }
-                                is FirJavaMethod -> enhancementScope.processFunctionsByName(declaration.name) { symbol ->
-                                    val enhanced = symbol.fir
-                                    if (enhanced !in renderedDeclarations) {
-                                        enhanced.accept(renderer, null)
-                                        renderer.newLine()
-                                        renderedDeclarations += enhanced
-                                    }
-                                }
-                                is FirJavaField -> enhancementScope.processPropertiesByName(declaration.name) { symbol ->
-                                    val enhanced = symbol.fir
-                                    if (enhanced !in renderedDeclarations) {
-                                        enhanced.accept(renderer, null)
-                                        renderer.newLine()
-                                        renderedDeclarations += enhanced
-                                    }
-                                }
-                                else -> {
-                                    declaration.accept(renderer, null)
-                                    renderer.newLine()
-                                    renderedDeclarations += declaration
-                                }
-                            }
-                        }
-                    }
-                }
                 processedJavaClasses += javaClass
             }
         }.toString()

compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/java/JavaClassRendering.kt

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2010-2020 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.fir.java
+
+import org.jetbrains.kotlin.fir.FirRenderer
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
+import org.jetbrains.kotlin.fir.java.declarations.FirJavaConstructor
+import org.jetbrains.kotlin.fir.java.declarations.FirJavaField
+import org.jetbrains.kotlin.fir.java.declarations.FirJavaMethod
+import org.jetbrains.kotlin.fir.java.scopes.JavaClassEnhancementScope
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.resolve.buildUseSiteMemberScope
+import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope
+
+fun renderJavaClass(renderer: FirRenderer, javaClass: FirJavaClass, session: FirSession) {
+    val enhancementScope = javaClass.buildUseSiteMemberScope(session, ScopeSession()).let {
+        when (it) {
+            is FirCompositeScope -> it.scopes.filterIsInstance<JavaClassEnhancementScope>().first()
+            is JavaClassEnhancementScope -> it
+            else -> null
+        }
+    }
+    if (enhancementScope == null) {
+        javaClass.accept(renderer, null)
+    } else {
+        renderer.visitMemberDeclaration(javaClass)
+        renderer.renderSupertypes(javaClass)
+        renderer.renderInBraces {
+            val renderedDeclarations = mutableListOf<FirDeclaration>()
+            for (declaration in javaClass.declarations) {
+                if (declaration in renderedDeclarations) continue
+                when (declaration) {
+                    is FirJavaConstructor -> enhancementScope.processDeclaredConstructors { symbol ->
+                        val enhanced = symbol.fir
+                        if (enhanced !in renderedDeclarations) {
+                            enhanced.accept(renderer, null)
+                            renderer.newLine()
+                            renderedDeclarations += enhanced
+                        }
+                    }
+                    is FirJavaMethod -> enhancementScope.processFunctionsByName(declaration.name) { symbol ->
+                        val enhanced = symbol.fir
+                        if (enhanced !in renderedDeclarations) {
+                            enhanced.accept(renderer, null)
+                            renderer.newLine()
+                            renderedDeclarations += enhanced
+                        }
+                    }
+                    is FirJavaField -> enhancementScope.processPropertiesByName(declaration.name) { symbol ->
+                        val enhanced = symbol.fir
+                        if (enhanced !in renderedDeclarations) {
+                            enhanced.accept(renderer, null)
+                            renderer.newLine()
+                            renderedDeclarations += enhanced
+                        }
+                    }
+                    else -> {
+                        declaration.accept(renderer, null)
+                        renderer.newLine()
+                        renderedDeclarations += declaration
+                    }
+                }
+            }
+        }
+    }
+}

idea/idea-frontend-fir/idea-fir-low-level-api/build.gradle.kts

@@ -27,6 +27,7 @@ dependencies {
     testCompile(toolsJar())
     testCompile(projectTests(":idea"))
     testCompile(projectTests(":compiler:tests-common"))
+    testCompile(projectTests(":compiler:fir:analysis-tests"))
     testCompile(projectTests(":idea:idea-test-framework"))
     testCompile(project(":kotlin-test:kotlin-test-junit"))
     testCompile(commonDep("junit:junit"))

idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/AbstractFirMultiModuleResolveTest.kt

@@ -12,30 +12,21 @@ import com.intellij.psi.PsiManager
 import com.intellij.psi.search.FileTypeIndex
 import org.jetbrains.kotlin.fir.FirRenderer
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.dependenciesWithoutSelf
 import org.jetbrains.kotlin.fir.extensions.BunchOfRegisteredExtensions
 import org.jetbrains.kotlin.fir.extensions.extensionService
 import org.jetbrains.kotlin.fir.extensions.registerExtensions
-import org.jetbrains.kotlin.fir.java.FirJavaModuleBasedSession
+import org.jetbrains.kotlin.fir.java.*
-import org.jetbrains.kotlin.fir.java.FirLibrarySession
-import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
-import org.jetbrains.kotlin.fir.java.JavaSymbolProvider
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
-import org.jetbrains.kotlin.fir.java.declarations.FirJavaMethod
-import org.jetbrains.kotlin.fir.java.scopes.JavaClassEnhancementScope
 import org.jetbrains.kotlin.fir.psi
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.buildUseSiteMemberScope
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCompositeSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl
 import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor
 import org.jetbrains.kotlin.fir.resolve.transformers.createAllTransformerBasedResolveProcessors
-import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.caches.project.IdeaModuleInfo
 import org.jetbrains.kotlin.idea.caches.project.isLibraryClasses
@@ -157,39 +148,7 @@ abstract class AbstractFirMultiModuleResolveTest : AbstractMultiModuleTest() {
                 val javaProvider = symbolProvider.providers.filterIsInstance<JavaSymbolProvider>().first()
                 for (javaClass in javaProvider.getJavaTopLevelClasses().sortedBy { it.name }) {
                     if (javaClass !is FirJavaClass || javaClass in processedJavaClasses) continue
-                    val enhancementScope = javaClass.buildUseSiteMemberScope(session, ScopeSession()).let {
+                    renderJavaClass(renderer, javaClass, session)
-                        when (it) {
-                            is FirCompositeScope -> it.scopes.filterIsInstance<JavaClassEnhancementScope>().first()
-                            is JavaClassEnhancementScope -> it
-                            else -> null
-                        }
-                    }
-                    if (enhancementScope == null) {
-                        javaClass.accept(renderer, null)
-                    } else {
-                        renderer.visitMemberDeclaration(javaClass)
-                        renderer.renderSupertypes(javaClass)
-                        renderer.renderInBraces {
-                            val renderedDeclarations = mutableListOf<FirDeclaration>()
-                            for (declaration in javaClass.declarations) {
-                                if (declaration in renderedDeclarations) continue
-                                if (declaration !is FirJavaMethod) {
-                                    declaration.accept(renderer, null)
-                                    renderer.newLine()
-                                    renderedDeclarations += declaration
-                                } else {
-                                    enhancementScope.processFunctionsByName(declaration.name) { symbol ->
-                                        val enhanced = symbol.fir
-                                        if (enhanced !in renderedDeclarations) {
-                                            enhanced.accept(renderer, null)
-                                            renderer.newLine()
-                                            renderedDeclarations += enhanced
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
                     processedJavaClasses += javaClass
                 }
             }