[Analysis API] rework renderer

^KTIJ-23268 fixed

analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/components/KtRendererProvider.kt

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2010-2022 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.impl.base.components
+
+import org.jetbrains.kotlin.analysis.api.KtAnalysisApiInternals
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.components.KtSymbolDeclarationRendererProvider
+import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
+import org.jetbrains.kotlin.analysis.api.renderer.declarations.KtDeclarationRenderer
+import org.jetbrains.kotlin.analysis.api.renderer.declarations.KtRendererTypeApproximator
+import org.jetbrains.kotlin.analysis.api.renderer.types.KtTypeRenderer
+import org.jetbrains.kotlin.analysis.api.symbols.KtDeclarationSymbol
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.utils.printer.prettyPrint
+import org.jetbrains.kotlin.types.Variance
+
+@KtAnalysisApiInternals
+open class KtRendererProviderImpl(
+    override val analysisSession: KtAnalysisSession,
+    override val token: KtLifetimeToken
+) : KtSymbolDeclarationRendererProvider() {
+
+    override fun renderType(type: KtType, renderer: KtTypeRenderer, position: Variance): String {
+        return with(analysisSession) {
+            val approximatedType = KtRendererTypeApproximator.TO_DENNOTABLE.approximateType(type, position)
+            prettyPrint { renderer.renderType(approximatedType, this) }
+        }
+    }
+
+    override fun renderDeclaration(symbol: KtDeclarationSymbol, renderer: KtDeclarationRenderer): String {
+        return with(analysisSession) {
+            prettyPrint { renderer.renderDeclaration(symbol, this) }
+        }
+    }
+}

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/expressionTypeProvider/AbstractDeclarationReturnTypeTest.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
+import org.jetbrains.kotlin.types.Variance
 
 abstract class AbstractDeclarationReturnTypeTest : AbstractAnalysisApiSingleFileTest() {
     override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
@@ -26,7 +27,7 @@ abstract class AbstractDeclarationReturnTypeTest : AbstractAnalysisApiSingleFile
                             val returnType = declaration.getReturnKtType()
                             append(declaration.getNameWithPositionString())
                             append(" : ")
-                            appendLine(returnType.render())
+                            appendLine(returnType.render(position = Variance.INVARIANT))
                         }
                     }
                     return super.visitDeclaration(declaration, indent + 2)

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/expressionTypeProvider/AbstractHLExpressionTypeTest.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.expressionTypeProvider
 
-import org.jetbrains.kotlin.analysis.api.components.KtTypeRendererOptions
-import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
+import org.jetbrains.kotlin.analysis.api.renderer.types.impl.KtTypeRendererForDebug
 import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiSingleFileTest
+import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
 import org.jetbrains.kotlin.analysis.test.framework.utils.executeOnPooledThreadInReadAction
 import org.jetbrains.kotlin.psi.KtBlockExpression
 import org.jetbrains.kotlin.psi.KtExpression
@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.psi.KtValueArgument
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
+import org.jetbrains.kotlin.types.Variance
 
 abstract class AbstractHLExpressionTypeTest : AbstractAnalysisApiSingleFileTest() {
     override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
@@ -32,7 +33,7 @@ abstract class AbstractHLExpressionTypeTest : AbstractAnalysisApiSingleFileTest(
             else -> null
         } ?: error("expect an expression but got ${selected.text}")
         val type = executeOnPooledThreadInReadAction {
-            analyseForTest(expression) { expression.getKtType()?.render(TYPE_RENDERING_OPTIONS) }
+            analyseForTest(expression) { expression.getKtType()?.render(renderer, position = Variance.INVARIANT) }
         }
         val actual = buildString {
             appendLine("expression: ${expression.text}")
@@ -42,6 +43,6 @@ abstract class AbstractHLExpressionTypeTest : AbstractAnalysisApiSingleFileTest(
     }
 
     companion object {
-        private val TYPE_RENDERING_OPTIONS = KtTypeRendererOptions.DEFAULT.copy(renderUnresolvedTypeAsResolved = false)
+        private val renderer = KtTypeRendererForDebug.WITH_QUALIFIED_NAMES
     }
 }

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/psiTypeProvider/AbstractAnalysisApiExpressionPsiTypeProviderTest.kt

@@ -6,13 +6,14 @@
 package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.psiTypeProvider
 
 import org.jetbrains.kotlin.analysis.api.analyze
-import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
 import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiSingleFileTest
+import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
+import org.jetbrains.kotlin.types.Variance
 
 abstract class AbstractAnalysisApiExpressionPsiTypeProviderTest : AbstractAnalysisApiSingleFileTest(){
     override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
@@ -22,7 +23,7 @@ abstract class AbstractAnalysisApiExpressionPsiTypeProviderTest : AbstractAnalys
                 ?: error("Not a typable expression ${declarationAtCaret::class} ${declarationAtCaret.text}")
             val psiType = returnType.asPsiType(declarationAtCaret)
             buildString {
-                appendLine("KtType: ${returnType.render()}")
+                appendLine("KtType: ${returnType.render(position = Variance.INVARIANT)}")
                 appendLine("PsiType: $psiType")
             }
         }

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/psiTypeProvider/AbstractAnalysisApiPsiTypeProviderTest.kt

@@ -17,6 +17,8 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.services.TestModuleStructure
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
+import org.jetbrains.kotlin.types.Variance
+import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 
 abstract class AbstractAnalysisApiPsiTypeProviderTest : AbstractAnalysisApiBasedTest() {
     override fun doTestByModuleStructure(moduleStructure: TestModuleStructure, testServices: TestServices) {
@@ -31,7 +33,7 @@ abstract class AbstractAnalysisApiPsiTypeProviderTest : AbstractAnalysisApiBased
             executeOnPooledThreadInReadAction {
                 analyze(declaration) {
                     val ktType = declaration.getReturnKtType()
-                    appendLine("KtType: ${ktType.render()}")
+                    appendLine("KtType: ${ktType.render(position = Variance.INVARIANT)}")
                     appendLine("PsiType: ${ktType.asPsiType(psiContext)}")
                 }
             }

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/smartCastProvider/AbstractHLSmartCastInfoTest.kt

@@ -5,14 +5,15 @@
 
 package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.smartCastProvider
 
-import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
 import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiSingleFileTest
+import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
 import org.jetbrains.kotlin.analysis.test.framework.utils.executeOnPooledThreadInReadAction
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
+import org.jetbrains.kotlin.types.Variance
 
 abstract class AbstractHLSmartCastInfoTest : AbstractAnalysisApiSingleFileTest() {
     override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
@@ -23,12 +24,12 @@ abstract class AbstractHLSmartCastInfoTest : AbstractAnalysisApiSingleFileTest()
                 buildString {
                     appendLine("expression: ${expression.text}")
                     appendLine("isStable: ${smartCastInfo?.isStable}")
-                    appendLine("smartCastType: ${smartCastInfo?.smartCastType?.render()}")
+                    appendLine("smartCastType: ${smartCastInfo?.smartCastType?.render(position = Variance.INVARIANT)}")
 
                     val receiverSmartCasts = expression.getImplicitReceiverSmartCast()
                     for (receiverSmartCast in receiverSmartCasts) {
                         appendLine("receiver: ${receiverSmartCast.kind}")
-                        appendLine("    smartCastType: ${receiverSmartCast.type.render()}")
+                        appendLine("    smartCastType: ${receiverSmartCast.type.render(position = Variance.INVARIANT)}")
                     }
                 }
             }

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/symbolDeclarationOverridesProvider/AbstractOverriddenDeclarationProviderTest.kt

@@ -6,12 +6,12 @@
 package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.symbolDeclarationOverridesProvider
 
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
-import org.jetbrains.kotlin.analysis.api.components.KtTypeRendererOptions
-import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
-import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiBasedSingleModuleTest
+import org.jetbrains.kotlin.analysis.api.renderer.types.impl.KtTypeRendererForSource
 import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSyntheticJavaPropertySymbol
+import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiBasedSingleModuleTest
+import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
 import org.jetbrains.kotlin.analysis.test.framework.utils.executeOnPooledThreadInReadAction
 import org.jetbrains.kotlin.analysis.utils.printer.parentsOfType
 import org.jetbrains.kotlin.psi.KtDeclaration
@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
+import org.jetbrains.kotlin.types.Variance
 
 abstract class AbstractOverriddenDeclarationProviderTest : AbstractAnalysisApiBasedSingleModuleTest() {
     override fun doTestByFileStructure(ktFiles: List<KtFile>, module: TestModule, testServices: TestServices) {
@@ -47,7 +48,7 @@ abstract class AbstractOverriddenDeclarationProviderTest : AbstractAnalysisApiBa
             symbol.valueParameters.forEachIndexed { index, parameter ->
                 append(parameter.name.identifier)
                 append(": ")
-                append(parameter.returnType.render(KtTypeRendererOptions.SHORT_NAMES))
+                append(parameter.returnType.render(KtTypeRendererForSource.WITH_SHORT_NAMES, position = Variance.INVARIANT))
                 if (index != symbol.valueParameters.lastIndex) {
                     append(", ")
                 }
@@ -55,7 +56,7 @@ abstract class AbstractOverriddenDeclarationProviderTest : AbstractAnalysisApiBa
             append(")")
         }
         append(": ")
-        append(symbol.returnType.render(KtTypeRendererOptions.SHORT_NAMES))
+        append(symbol.returnType.render(KtTypeRendererForSource.WITH_SHORT_NAMES, position = Variance.INVARIANT))
     }
 
     @Suppress("unused")

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/symbolDeclarationRenderer/AbstractRendererTest.kt

@@ -5,9 +5,12 @@
 
 package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.symbolDeclarationRenderer
 
-import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions
-import org.jetbrains.kotlin.analysis.api.components.KtTypeRendererOptions
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.renderer.declarations.bodies.KtRendererBodyMemberScopeSorter
+import org.jetbrains.kotlin.analysis.api.renderer.declarations.impl.KtDeclarationRendererForSource
+import org.jetbrains.kotlin.analysis.api.renderer.declarations.renderers.KtClassifierBodyRenderer
 import org.jetbrains.kotlin.analysis.api.symbols.KtDeclarationSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithMembers
 import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiSingleFileTest
 import org.jetbrains.kotlin.analysis.test.framework.utils.executeOnPooledThreadInReadAction
 import org.jetbrains.kotlin.psi.KtFile
@@ -17,19 +20,24 @@ import org.jetbrains.kotlin.test.services.assertions
 
 abstract class AbstractRendererTest : AbstractAnalysisApiSingleFileTest() {
     override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
-        val options = KtDeclarationRendererOptions.DEFAULT.copy(
-            approximateTypes = true,
-            renderClassMembers = true,
-            typeRendererOptions = KtTypeRendererOptions.SHORT_NAMES,
-            sortNestedDeclarations = true
-        )
+        val renderer = KtDeclarationRendererForSource.WITH_SHORT_NAMES.with {
+            classifierBodyRenderer = KtClassifierBodyRenderer.BODY_WITH_MEMBERS
+            bodyMemberScopeSorter = object : KtRendererBodyMemberScopeSorter {
+                context(KtAnalysisSession)
+                override fun sortMembers(members: List<KtDeclarationSymbol>, owner: KtSymbolWithMembers): List<KtDeclarationSymbol> {
+                    return KtRendererBodyMemberScopeSorter.ENUM_ENTRIES_AT_BEGINING
+                        .sortMembers(members, owner)
+                        .sortedBy { it.render() }
+                }
+            }
+        }
 
         val actual = executeOnPooledThreadInReadAction {
             buildString {
                 ktFile.declarations.forEach { declaration ->
                     analyseForTest(declaration) {
                         val symbol = declaration.getSymbol() as? KtDeclarationSymbol ?: return@analyseForTest
-                        append(symbol.render(options))
+                        append(symbol.render(renderer))
                         appendLine()
                         appendLine()
                     }

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/testUtils.kt

@@ -10,11 +10,10 @@ import org.jetbrains.kotlin.analysis.api.KtAnalysisApiInternals
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.calls.KtCall
 import org.jetbrains.kotlin.analysis.api.calls.KtCallableMemberCall
-import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions
-import org.jetbrains.kotlin.analysis.api.components.KtTypeRendererOptions
 import org.jetbrains.kotlin.analysis.api.diagnostics.KtDiagnostic
 import org.jetbrains.kotlin.analysis.api.impl.base.KtMapBackedSubstitutor
-import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.containingDeclarationProvider.AbstractContainingDeclarationProviderByMemberScopeTest
+import org.jetbrains.kotlin.analysis.api.renderer.declarations.impl.KtDeclarationRendererForSource
+import org.jetbrains.kotlin.analysis.api.renderer.declarations.modifiers.renderers.KtRendererModifierFilter
 import org.jetbrains.kotlin.analysis.api.scopes.KtScope
 import org.jetbrains.kotlin.analysis.api.signatures.KtCallableSignature
 import org.jetbrains.kotlin.analysis.api.signatures.KtFunctionLikeSignature
@@ -26,6 +25,7 @@ import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.utils.printer.prettyPrint
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.types.Variance
 import kotlin.reflect.KProperty1
 import kotlin.reflect.KVisibility
 import kotlin.reflect.full.memberProperties
@@ -118,15 +118,15 @@ internal fun KtAnalysisSession.prettyPrintSignature(signature: KtCallableSignatu
     when (signature) {
         is KtFunctionLikeSignature -> {
             append("fun ")
-            signature.receiverType?.let { append('.'); append(it.render()) }
+            signature.receiverType?.let { append('.'); append(it.render(position = Variance.INVARIANT)) }
             append((signature.symbol as KtNamedSymbol).name.asString())
             printCollection(signature.valueParameters, prefix = "(", postfix = ")") { parameter ->
                 append(parameter.name.asString())
                 append(": ")
-                append(parameter.returnType.render())
+                append(parameter.returnType.render(position = Variance.INVARIANT))
             }
             append(": ")
-            append(signature.returnType.render())
+            append(signature.returnType.render(position = Variance.INVARIANT))
         }
         is KtVariableLikeSignature -> {
             val symbol = signature.symbol
@@ -134,10 +134,10 @@ internal fun KtAnalysisSession.prettyPrintSignature(signature: KtCallableSignatu
                 append(if (symbol.isVal) "val" else "var")
                 append(" ")
             }
-            signature.receiverType?.let { append('.'); append(it.render()) }
+            signature.receiverType?.let { append('.'); append(it.render(position = Variance.INVARIANT)) }
             append((symbol as KtNamedSymbol).name.asString())
             append(": ")
-            append(signature.returnType.render())
+            append(signature.returnType.render(position = Variance.INVARIANT))
         }
     }
 }
@@ -157,10 +157,11 @@ internal fun renderScopeWithParentDeclarations(scope: KtScope): String = prettyP
         else -> error("unknown symbol $this")
     }
 
-    val renderingOptions = KtDeclarationRendererOptions.DEFAULT.copy(
-        typeRendererOptions = KtTypeRendererOptions.SHORT_NAMES,
-        modifiers = emptySet()
-    )
+    val renderingOptions = KtDeclarationRendererForSource.WITH_SHORT_NAMES.with {
+        modifiersRenderer = modifiersRenderer.with {
+            modifierFilter = KtRendererModifierFilter.NONE
+        }
+    }
 
     printCollection(scope.getAllSymbols().toList(), separator = "\n\n") { symbol ->
         val containingDeclaration = symbol.getContainingSymbol() as KtClassLikeSymbol

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeCreator/AbstractTypeParameterTypeTest.kt

@@ -6,13 +6,14 @@
 package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.typeCreator
 
 import org.jetbrains.kotlin.analysis.api.components.buildTypeParameterType
-import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
 import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiSingleFileTest
+import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtTypeParameter
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
+import org.jetbrains.kotlin.types.Variance
 
 abstract class AbstractTypeParameterTypeTest : AbstractAnalysisApiSingleFileTest() {
     override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
@@ -23,7 +24,7 @@ abstract class AbstractTypeParameterTypeTest : AbstractAnalysisApiSingleFileTest
             val ktType = buildTypeParameterType(symbol)
             buildString {
                 appendLine("expression: ${expressionAtCaret.text}")
-                appendLine("ktType: ${ktType.render()}")
+                appendLine("ktType: ${ktType.render(position = Variance.INVARIANT)}")
             }
         }
 

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeInfoProvider/AbstractFunctionClassKindTest.kt

@@ -5,14 +5,15 @@
 
 package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.typeInfoProvider
 
-import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
 import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiSingleFileTest
+import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
 import org.jetbrains.kotlin.analysis.test.framework.utils.executeOnPooledThreadInReadAction
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
+import org.jetbrains.kotlin.types.Variance
 
 abstract class AbstractFunctionClassKindTest  : AbstractAnalysisApiSingleFileTest() {
 
@@ -22,7 +23,7 @@ abstract class AbstractFunctionClassKindTest  : AbstractAnalysisApiSingleFileTes
         val (type, functionClassKind) = executeOnPooledThreadInReadAction {
             analyseForTest(expressionAtCaret) {
                 val functionType = expressionAtCaret.getExpectedType()
-                functionType?.render() to functionType?.functionClassKind
+                functionType?.render(position = Variance.INVARIANT) to functionType?.functionClassKind
             }
         }
         val actual = buildString {

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeInfoProvider/AbstractIsDenotableTest.kt

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.AdditionalSourceProvider
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
+import org.jetbrains.kotlin.types.Variance
 import java.io.File
 
 abstract class AbstractIsDenotableTest : AbstractAnalysisApiSingleFileTest() {
@@ -68,7 +69,7 @@ abstract class AbstractIsDenotableTest : AbstractAnalysisApiSingleFileTest() {
                             true -> append("@Denotable")
                             false -> append("@Nondenotable")
                         }
-                        append("(\"${ktType.render()}\") ")
+                        append("(\"${ktType.render(position = Variance.INVARIANT)}\") ")
                         append(base.text)
                     }
                 }

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeProvider/AbstractAnalysisApiGetSuperTypesTest.kt

@@ -6,15 +6,16 @@
 package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.typeProvider
 
 import org.jetbrains.kotlin.analysis.api.analyze
-import org.jetbrains.kotlin.analysis.api.components.KtTypeRendererOptions
-import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
-import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiSingleFileTest
+import org.jetbrains.kotlin.analysis.api.renderer.types.impl.KtTypeRendererForDebug
 import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiSingleFileTest
+import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
 import org.jetbrains.kotlin.analysis.test.framework.utils.executeOnPooledThreadInReadAction
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
+import org.jetbrains.kotlin.types.Variance
 
 abstract class AbstractAnalysisApiGetSuperTypesTest : AbstractAnalysisApiSingleFileTest(){
     override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
@@ -32,7 +33,7 @@ abstract class AbstractAnalysisApiGetSuperTypesTest : AbstractAnalysisApiSingleF
                     fun List<KtType>.print(name: String) {
                         appendLine(name)
                         for (type in this) {
-                            appendLine(type.render(KtTypeRendererOptions.DEFAULT))
+                            appendLine(type.render(KtTypeRendererForDebug.WITH_QUALIFIED_NAMES, position = Variance.INVARIANT))
                         }
                         appendLine()
                     }

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/references/AbstractReferenceResolveTest.kt

@@ -6,10 +6,11 @@
 package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.references
 
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
-import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions
-import org.jetbrains.kotlin.analysis.api.components.RendererModifier
 import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.references.TestReferenceResolveResultRenderer.renderResolvedTo
-import org.jetbrains.kotlin.analysis.api.symbols.*
+import org.jetbrains.kotlin.analysis.api.renderer.base.annotations.KtRendererAnnotationsFilter
+import org.jetbrains.kotlin.analysis.api.renderer.declarations.impl.KtDeclarationRendererForDebug
+import org.jetbrains.kotlin.analysis.api.renderer.declarations.renderers.callables.KtPropertyAccessorsRenderer
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestDirectives
 import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiBasedSingleModuleTest
 import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
@@ -89,9 +90,11 @@ abstract class AbstractReferenceResolveTest : AbstractAnalysisApiBasedSingleModu
         )
     }
 
-    private val renderingOptions = KtDeclarationRendererOptions.DEFAULT.copy(
-        modifiers = RendererModifier.DEFAULT - RendererModifier.ANNOTATIONS,
-        sortNestedDeclarations = true
-    )
+    private val renderingOptions = KtDeclarationRendererForDebug.WITH_QUALIFIED_NAMES.with {
+        annotationRenderer = annotationRenderer.with {
+            annotationFilter = KtRendererAnnotationsFilter.NONE
+        }
+        propertyAccessorsRenderer = KtPropertyAccessorsRenderer.NONE
+    }
 
 }

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/references/TestReferenceResolveResultRenderer.kt

@@ -6,36 +6,38 @@
 package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.references
 
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
-import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions
+import org.jetbrains.kotlin.analysis.api.renderer.declarations.KtDeclarationRenderer
+import org.jetbrains.kotlin.analysis.api.renderer.declarations.impl.KtDeclarationRendererForDebug
 import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtNamedSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithKind
 import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.types.Variance
 
 object TestReferenceResolveResultRenderer {
     fun KtAnalysisSession.renderResolvedTo(
         symbols: List<KtSymbol>,
-        renderingOptions: KtDeclarationRendererOptions = KtDeclarationRendererOptions.DEFAULT
+        renderer: KtDeclarationRenderer = KtDeclarationRendererForDebug.WITH_QUALIFIED_NAMES,
     ) =
-        symbols.map { renderResolveResult(it, renderingOptions) }
+        symbols.map { renderResolveResult(it, renderer) }
             .sorted()
             .withIndex()
             .joinToString(separator = "\n") { "${it.index}: ${it.value}" }
 
     private fun KtAnalysisSession.renderResolveResult(
         symbol: KtSymbol,
-        renderingOptions: KtDeclarationRendererOptions
+        renderer: KtDeclarationRenderer
     ): String {
         return buildString {
             symbolContainerFqName(symbol)?.let { fqName ->
                 append("(in $fqName) ")
             }
             when (symbol) {
-                is KtDeclarationSymbol -> append(symbol.render(renderingOptions))
+                is KtDeclarationSymbol -> append(symbol.render(renderer))
                 is KtPackageSymbol -> append("package ${symbol.fqName}")
                 is KtReceiverParameterSymbol -> {
                     append("extension receiver with type ")
-                    append(symbol.type.render(renderingOptions.typeRendererOptions))
+                    append(symbol.type.render(renderer.typeRenderer, position = Variance.INVARIANT))
                 }
                 else -> error("Unexpected symbol ${symbol::class}")
             }

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/scopes/AbstractTypeScopeTest.kt

@@ -11,10 +11,10 @@
 package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.scopes
 
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
-import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions
-import org.jetbrains.kotlin.analysis.api.components.RendererModifier
 import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.prettyPrintSignature
 import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.stringRepresentation
+import org.jetbrains.kotlin.analysis.api.renderer.declarations.impl.KtDeclarationRendererForSource
+import org.jetbrains.kotlin.analysis.api.renderer.declarations.modifiers.renderers.KtRendererModifierFilter
 import org.jetbrains.kotlin.analysis.api.scopes.KtScope
 import org.jetbrains.kotlin.analysis.api.scopes.KtTypeScope
 import org.jetbrains.kotlin.analysis.api.symbols.DebugSymbolRenderer
@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
+import org.jetbrains.kotlin.types.Variance
 
 abstract class AbstractTypeScopeTest : AbstractAnalysisApiSingleFileTest() {
     override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
@@ -38,7 +39,7 @@ abstract class AbstractTypeScopeTest : AbstractAnalysisApiSingleFileTest() {
 
             val scopeStringRepresentation = prettyPrint {
                 appendLine("expression: ${expression.text}")
-                appendLine("KtType: ${type.render()}")
+                appendLine("KtType: ${type.render(position = Variance.INVARIANT)}")
                 appendLine()
                 appendLine("KtTypeScope:")
                 appendLine(typeScope?.let { renderForTests(it) } ?: "NO_SCOPE")
@@ -95,9 +96,14 @@ abstract class AbstractTypeScopeTest : AbstractAnalysisApiSingleFileTest() {
         val callables = scope.getCallableSymbols().toList()
         return prettyPrint {
             callables.forEach {
-                appendLine(it.render(options = KtDeclarationRendererOptions.DEFAULT.copy(modifiers = RendererModifier.NONE)))
+                appendLine(it.render(renderer))
             }
         }
     }
 
+    companion object {
+        private val renderer = KtDeclarationRendererForSource.WITH_QUALIFIED_NAMES.with {
+            modifiersRenderer = modifiersRenderer.with { modifierFilter = KtRendererModifierFilter.NONE }
+        }
+    }
 }

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/symbols/AbstractSymbolTest.kt

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.symbols
 
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
-import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions
 import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.symbols.SymbolTestDirectives.DO_NOT_CHECK_NON_PSI_SYMBOL_RESTORE
 import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.symbols.SymbolTestDirectives.DO_NOT_CHECK_NON_PSI_SYMBOL_RESTORE_K1
 import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.symbols.SymbolTestDirectives.DO_NOT_CHECK_NON_PSI_SYMBOL_RESTORE_K2
@@ -14,6 +13,8 @@ import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.symbols.SymbolTest
 import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.symbols.SymbolTestDirectives.DO_NOT_CHECK_SYMBOL_RESTORE_K1
 import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.symbols.SymbolTestDirectives.DO_NOT_CHECK_SYMBOL_RESTORE_K2
 import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.symbols.SymbolTestDirectives.PRETTY_RENDERING_MODE
+import org.jetbrains.kotlin.analysis.api.renderer.declarations.impl.KtDeclarationRendererForDebug
+import org.jetbrains.kotlin.analysis.api.renderer.declarations.renderers.KtClassifierBodyRenderer
 import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
@@ -33,7 +34,7 @@ import org.jetbrains.kotlin.test.services.assertions
 import kotlin.test.fail
 
 abstract class AbstractSymbolTest : AbstractAnalysisApiSingleFileTest() {
-    private val renderingOptions = KtDeclarationRendererOptions.DEFAULT
+    private val renderer = KtDeclarationRendererForDebug.WITH_QUALIFIED_NAMES
 
     open val prettyRenderMode: PrettyRenderingMode = PrettyRenderingMode.RENDER_SYMBOLS_LINE_BY_LINE
 
@@ -52,8 +53,10 @@ abstract class AbstractSymbolTest : AbstractAnalysisApiSingleFileTest() {
         val directiveToIgnoreNonPsiSymbolRestore = directives.doNotCheckNonPsiSymbolRestoreDirective()
 
         val prettyRenderOptions = when (directives.singleOrZeroValue(PRETTY_RENDERING_MODE) ?: prettyRenderMode) {
-            PrettyRenderingMode.RENDER_SYMBOLS_LINE_BY_LINE -> renderingOptions
-            PrettyRenderingMode.RENDER_SYMBOLS_NESTED -> renderingOptions.copy(renderClassMembers = true)
+            PrettyRenderingMode.RENDER_SYMBOLS_LINE_BY_LINE -> renderer
+            PrettyRenderingMode.RENDER_SYMBOLS_NESTED -> renderer.with {
+                classifierBodyRenderer = KtClassifierBodyRenderer.BODY_WITH_MEMBERS
+            }
         }
 
         fun KtSymbol.safePointer(): PointerWrapper? {

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/types/AbstractAnalysisApiSubstitutorsTest.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
+import org.jetbrains.kotlin.types.Variance
 
 abstract class AbstractAnalysisApiSubstitutorsTest : AbstractAnalysisApiSingleFileTest() {
     override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
@@ -29,9 +30,9 @@ abstract class AbstractAnalysisApiSubstitutorsTest : AbstractAnalysisApiSingleFi
 
             prettyPrint {
                 appendLine("PSI type: ${declaration.typeReference?.text}")
-                appendLine("KtType: ${type.render()}")
-                appendLine("substitutor.substitute: ${substituted.render()}")
-                appendLine("substitutor.substituteOrNull: ${substitutedOrNull?.render()}")
+                appendLine("KtType: ${type.render(position = Variance.INVARIANT)}")
+                appendLine("substitutor.substitute: ${substituted.render(position = Variance.INVARIANT)}")
+                appendLine("substitutor.substituteOrNull: ${substitutedOrNull?.render(position = Variance.INVARIANT)}")
             }
         }
         testServices.assertions.assertEqualsToTestDataFileSibling(actual)