Support for nested typealiases (#4261)

* Add `WithTypealiases` interface to documentables * Copy typealiases everywhere * Merge typealiases in multiplatform projects * Fix DocumentableReplacerTransformer: consider typealiases when computing if the classlike was changed * Add test for nested typealiases in SuppressTagFilterTest.kt * Change the rendering of typealias names * Ensure ABI compatibility of documentables that implement `WithTypealiases` * Add test that checks nested typealiases with type parameters * Remove the use of `signatureForProjection` in `regularSignature` for typealiases, replace it with custom implementation (cherry picked from commit b49856b)

Author: AbdullinAM

dokka-subprojects/analysis-java-psi/src/main/kotlin/org/jetbrains/dokka/analysis/java/parsers/DokkaPsiParser.kt

@@ -317,6 +317,7 @@ internal class DokkaPsiParser(
  properties = fields.filter { it !is PsiEnumConstant }
  .map { parseField(it, accessors[it].orEmpty()) },
  classlikes = classlikes.await(),
+ typealiases = emptyList(),
  visibility = visibility,
  companion = null,
  constructors = parseConstructors(dri),
@@ -340,6 +341,7 @@ internal class DokkaPsiParser(
  functions = allFunctions.await(),
  properties = allFields.await(),
  classlikes = classlikes.await(),
+ typealiases = emptyList(),
  visibility = visibility,
  companion = null,
  generics = mapTypeParameters(dri),
@@ -361,6 +363,7 @@ internal class DokkaPsiParser(
  functions = allFunctions.await(),
  properties = allFields.await(),
  classlikes = classlikes.await(),
+ typealiases = emptyList(),
  sources = source,
  visibility = visibility,
  companion = null,

dokka-subprojects/analysis-kotlin-descriptors-compiler/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/compiler/configuration/DRIFactory.kt

@@ -23,7 +23,7 @@ internal fun DRI.Companion.from(descriptor: DeclarationDescriptor) = descriptor.
 
  DRI(
  packageName = firstIsInstanceOrNull<PackageFragmentDescriptor>()?.fqName?.asString() ?: "",
- classNames = (filterIsInstance<ClassDescriptor>() + filterIsInstance<TypeAliasDescriptor>()).toList()
+ classNames = filter { it is ClassDescriptor || it is TypeAliasDescriptor }.toList()
  .takeIf { it.isNotEmpty() }
  ?.asReversed()
  ?.joinToString(separator = ".") { it.name.asString() },

dokka-subprojects/analysis-kotlin-descriptors-compiler/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/compiler/translator/DefaultDescriptorToDocumentableTranslator.kt

@@ -227,6 +227,7 @@ private class DokkaDescriptorVisitor(
  val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
  val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
  val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
+ val typealiases = async { descriptorsWithKind.typealiases.visitTypealiases() }
  val generics = async { descriptor.declaredTypeParameters.parallelMap { it.toVariantTypeParameter() } }
 
  DInterface(
@@ -235,6 +236,7 @@ private class DokkaDescriptorVisitor(
  functions = functions.await(),
  properties = properties.await(),
  classlikes = classlikes.await(),
+ typealiases = typealiases.await(),
  sources = descriptor.createSources(),
  expectPresentInSet = sourceSet.takeIf { isExpect },
  visibility = descriptor.visibility.toDokkaVisibility().toSourceSetDependent(),
@@ -269,13 +271,15 @@ private class DokkaDescriptorVisitor(
  val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
  val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
  val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
+ val typealiases = async { descriptorsWithKind.typealiases.visitTypealiases() }
 
  DObject(
  dri = driWithPlatform.dri,
  name = descriptor.name.asString(),
  functions = functions.await(),
  properties = properties.await(),
  classlikes = classlikes.await(),
+ typealiases = typealiases.await(),
  sources = descriptor.createSources(),
  expectPresentInSet = sourceSet.takeIf { isExpect },
  visibility = descriptor.visibility.toDokkaVisibility().toSourceSetDependent(),
@@ -307,6 +311,7 @@ private class DokkaDescriptorVisitor(
  val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
  val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
  val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
+ val typealiases = async { descriptorsWithKind.typealiases.visitTypealiases() }
  val constructors =
  async { descriptor.constructors.parallelMap { visitConstructorDescriptor(it, driWithPlatform) } }
  val entries = async { descriptorsWithKind.enumEntries.visitEnumEntries(driWithPlatform) }
@@ -319,6 +324,7 @@ private class DokkaDescriptorVisitor(
  functions = functions.await(),
  properties = properties.await(),
  classlikes = classlikes.await(),
+ typealiases = typealiases.await(),
  sources = descriptor.createSources(),
  expectPresentInSet = sourceSet.takeIf { isExpect },
  visibility = descriptor.visibility.toDokkaVisibility().toSourceSetDependent(),
@@ -438,6 +444,7 @@ private class DokkaDescriptorVisitor(
  val functions = async { regularFunctions.visitFunctions(driWithPlatform) }
  val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform, accessors) }
  val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
+ val typealiases = async { descriptorsWithKind.typealiases.visitTypealiases() }
  val generics = async { descriptor.declaredTypeParameters.parallelMap { it.toVariantTypeParameter() } }
  val constructors = async {
  descriptor.constructors.parallelMap {
@@ -456,6 +463,7 @@ private class DokkaDescriptorVisitor(
  functions = functions.await(),
  properties = properties.await(),
  classlikes = classlikes.await(),
+ typealiases = typealiases.await(),
  sources = actual,
  expectPresentInSet = sourceSet.takeIf { isExpect },
  visibility = descriptor.visibility.toDokkaVisibility().toSourceSetDependent(),

dokka-subprojects/analysis-kotlin-symbols/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/symbols/translators/DefaultSymbolToDocumentableTranslator.kt

@@ -20,7 +20,6 @@ import org.jetbrains.dokka.analysis.kotlin.symbols.kdoc.hasGeneratedKDocDocument
 import org.jetbrains.dokka.analysis.kotlin.symbols.translators.AnnotationTranslator.Companion.getPresentableName
 import org.jetbrains.dokka.analysis.kotlin.symbols.utils.typeConstructorsBeingExceptions
 import org.jetbrains.dokka.links.*
-import org.jetbrains.dokka.links.Callable
 import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.Visibility
 import org.jetbrains.dokka.model.doc.*
@@ -189,7 +188,7 @@ internal class DokkaSymbolVisitor(
  val isActual = namedClassSymbol.isActual
  val documentation = getDocumentation(namedClassSymbol)?.toSourceSetDependent() ?: emptyMap()
 
- val (constructors, functions, properties, classlikesWithoutCompanion) = getDokkaScopeFrom(namedClassSymbol, dri)
+ val (constructors, functions, properties, classlikesWithoutCompanion, typeAliases) = getDokkaScopeFrom(namedClassSymbol, dri)
 
  val companionObject = namedClassSymbol.companionObject?.let {
  visitClassSymbol(
@@ -222,6 +221,7 @@ internal class DokkaSymbolVisitor(
  functions = functions,
  properties = properties,
  classlikes = classlikes,
+ typealiases = typeAliases,
  sources = namedClassSymbol.getSource(),
  expectPresentInSet = sourceSet.takeIf { isExpect },
  visibility = namedClassSymbol.getDokkaVisibility().toSourceSetDependent(),
@@ -245,6 +245,7 @@ internal class DokkaSymbolVisitor(
  functions = functions,
  properties = properties,
  classlikes = classlikes,
+ typealiases = typeAliases,
  sources = namedClassSymbol.getSource(),
  expectPresentInSet = sourceSet.takeIf { isExpect },
  visibility = namedClassSymbol.getDokkaVisibility().toSourceSetDependent(),
@@ -269,6 +270,7 @@ internal class DokkaSymbolVisitor(
  functions = functions,
  properties = properties,
  classlikes = classlikes,
+ typealiases = typeAliases,
  sources = namedClassSymbol.getSource(), //
  expectPresentInSet = sourceSet.takeIf { isExpect },
  visibility = namedClassSymbol.getDokkaVisibility().toSourceSetDependent(),
@@ -343,6 +345,7 @@ internal class DokkaSymbolVisitor(
  functions = functions,
  properties = properties,
  classlikes = classlikes,
+ typealiases = typeAliases,
  sources = namedClassSymbol.getSource(),
  expectPresentInSet = sourceSet.takeIf { isExpect },
  visibility = namedClassSymbol.getDokkaVisibility().toSourceSetDependent(),
@@ -371,7 +374,8 @@ internal class DokkaSymbolVisitor(
  val constructors: List<DFunction>,
  val functions: List<DFunction>,
  val properties: List<DProperty>,
- val classlikesWithoutCompanion: List<DClasslike>
+ val classlikesWithoutCompanion: List<DClasslike>,
+ val typeAliases: List<DTypeAlias>,
  )
 
  /**
@@ -400,7 +404,10 @@ internal class DokkaSymbolVisitor(
 
  // Dokka K1 does not show inherited nested and inner classes,
  // so it should show only classifiers (classes and objects) explicitly declared
- val classifiers = if(includeStaticScope) namedClassOrObjectSymbol.staticMemberScope.classifiers else emptySequence()
+ val classifiers = when {
+ includeStaticScope -> namedClassOrObjectSymbol.staticMemberScope.classifiers.toList()
+ else -> emptyList()
+ }
 
  val syntheticJavaProperties =
  namedClassOrObjectSymbol.defaultType.syntheticJavaPropertiesScope?.getCallableSignatures()
@@ -429,21 +436,24 @@ internal class DokkaSymbolVisitor(
  syntheticJavaProperties.map { visitPropertySymbol(it, dri) } +
  javaFields.map { visitJavaFieldSymbol(it, dri) }
 
+ val typealiases = classifiers.filterIsInstance<KaTypeAliasSymbol>()
+ .map { visitTypeAliasSymbol(it, dri) }
 
- fun Sequence<KaNamedClassSymbol>.filterOutCompanion() =
+ fun List<KaNamedClassSymbol>.filterOutCompanion() =
  filterNot {
  it.classKind == KaClassKind.COMPANION_OBJECT
  }
 
  val classlikes = classifiers.filterIsInstance<KaNamedClassSymbol>()
- .filterOutCompanion() // also, this is a hack to filter out companion for enum
+ .filterOutCompanion()
  .map { visitClassSymbol(it, dri) }
 
  return DokkaScope(
  constructors = constructors,
  functions = functions,
  properties = properties,
- classlikesWithoutCompanion = classlikes.toList()
+ classlikesWithoutCompanion = classlikes,
+ typeAliases = typealiases,
  )
  }