Merge branch 'master' into adam/support-agp-kotlin-builtin

Author: adam-enko

dokka-integration-tests/gradle/projects/it-android/expectedData/html/it-android/it.android/-integration-test-activity/index.html

@@ -33,6 +33,12 @@ dependencyResolutionManagement {
         google {
             setUrl("https://cache-redirector.jetbrains.com/dl.google.com/dl/android/maven2")
             name = "Google-JBCache"
+            mavenContent {
+                // https://github.com/gradle/gradle/issues/35562
+                includeGroupAndSubgroups("com.android")
+                includeGroupAndSubgroups("com.google")
+                includeGroupAndSubgroups("androidx")
+            }
         }
     }
 

dokka-runners/dokka-gradle-plugin/settings.gradle.kts

@@ -9,6 +9,7 @@ import org.jetbrains.dokka.links.*
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
+import org.jetbrains.kotlin.resolve.calls.components.isVararg
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExtensionReceiver
 import org.jetbrains.kotlin.types.KotlinType
@@ -27,7 +28,10 @@ internal fun TypeReference.Companion.from(d: ReceiverParameterDescriptor): TypeR
     }
 
 internal fun TypeReference.Companion.from(d: ValueParameterDescriptor): TypeReference =
-    fromPossiblyNullable(d.type, emptyList())
+    when {
+        d.isVararg -> Vararg(fromPossiblyNullable(d.varargElementType!!, emptyList()))
+        else -> fromPossiblyNullable(d.type, emptyList())
+    }
 
 internal fun TypeReference.Companion.from(@Suppress("UNUSED_PARAMETER") p: PsiClass) = TypeReference
 
@@ -54,6 +58,7 @@ private fun TypeReference.Companion.from(t: KotlinType, paramTrace: List<KotlinT
         is TypeParameterDescriptor -> TypeParam(
             d.upperBounds.map { fromPossiblyNullable(it, paramTrace + t) }
         )
+
         else -> TypeConstructor(
             t.constructorName.orEmpty(),
             t.arguments.map { fromProjection(it, paramTrace) }

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

@@ -57,7 +57,7 @@ internal fun KaSession.getDRIFromConstructor(symbol: KaConstructorSymbol): DRI {
     return containingClassId.createDRI().copy(
         callable = Callable(
             name = containingClassId.shortClassName.asString(),
-            params = symbol.valueParameters.map { getTypeReferenceFrom(it.returnType) }
+            params = symbol.valueParameters.map { getTypeReferenceFrom(it.returnType, isVararg = it.isVararg) }
         )
     )
 }
@@ -71,7 +71,7 @@ internal fun KaSession.getDRIFromVariable(symbol: KaVariableSymbol): DRI {
 
 
 internal fun KaSession.getDRIFromFunction(symbol: KaFunctionSymbol): DRI {
-    val params = symbol.valueParameters.map { getTypeReferenceFrom(it.returnType) }
+    val params = symbol.valueParameters.map { getTypeReferenceFrom(it.returnType, isVararg = it.isVararg) }
     val contextParams = @OptIn(KaExperimentalApi::class) symbol.contextParameters.map { getTypeReferenceFrom(it.returnType) }
     val receiver = symbol.receiverType?.let {
         getTypeReferenceFrom(it)
@@ -100,7 +100,7 @@ internal fun KaSession.getDRIFromReceiverParameter(receiverParameterSymbol: KaRe
     getDRIFromReceiverType(receiverParameterSymbol.returnType)
 
 private fun KaSession.getDRIFromReceiverType(type: KaType): DRI {
-    return when(type) {
+    return when (type) {
         is KaClassType -> getDRIFromClassType(type)
         is KaTypeParameterType -> getDRIFromTypeParameter(type.symbol)
         is KaDefinitelyNotNullType -> getDRIFromReceiverType(type.original)
@@ -149,7 +149,7 @@ private fun KaSession.getDRIFromLocalFunction(symbol: KaFunctionSymbol): DRI {
     return containingSymbolDRI.copy(
         callable = Callable(
             (symbol as? KaNamedSymbol)?.name?.asString() ?: "",
-            params = symbol.valueParameters.map { getTypeReferenceFrom(it.returnType) },
+            params = symbol.valueParameters.map { getTypeReferenceFrom(it.returnType, isVararg = it.isVararg) },
             receiver = symbol.receiverType?.let {
                 getTypeReferenceFrom(it)
             }

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

@@ -753,7 +753,7 @@ internal class DokkaSymbolVisitor(
         extra = PropertyContainer.withAll(
             valueParameterSymbol.additionalExtras()?.toSourceSetDependent()?.toAdditionalModifiers(),
             getDokkaAnnotationsFrom(valueParameterSymbol)?.toSourceSetDependent()?.toAnnotations(),
-            valueParameterSymbol.getDefaultValue()?.let { DefaultValue(it.toSourceSetDependent()) }
+            getDefaultValue(valueParameterSymbol, index)?.let { DefaultValue(it.toSourceSetDependent()) }
         )
     )
 
@@ -788,9 +788,29 @@ internal class DokkaSymbolVisitor(
         )
     )
 
-    private fun KaValueParameterSymbol.getDefaultValue(): Expression? =
-        if (origin == KaSymbolOrigin.SOURCE) (psi as? KtParameter)?.defaultValue?.toDefaultValueExpression()
-        else null
+    /**
+     * TODO https://youtrack.jetbrains.com/issue/KT-61254/Analysis-API-Add-a-default-value-for-KtValueParameterSymbol
+     * Retrieves the default value of a value parameter, if available from sources.
+     * It may be `null` if the owner function comes from a non-source file.
+     */
+    private fun KaSession.getDefaultValue(symbol: KaValueParameterSymbol, parameterIndex: Int): Expression? {
+        fun KaValueParameterSymbol.getExplicitDefaultValue(): Expression? =
+            if (origin == KaSymbolOrigin.SOURCE) (psi as? KtParameter)?.defaultValue?.toDefaultValueExpression() else null
+        fun KaDeclarationSymbol.findMatchingParameterWithDefaultValue(): Expression? =
+            (this as? KaFunctionSymbol)?.valueParameters?.getOrNull(parameterIndex)?.getExplicitDefaultValue()
+
+        val result = symbol.getExplicitDefaultValue()
+        return if (result != null)
+            result
+        else { // in the case of fake declarations
+            val ownerFunction = symbol.containingDeclaration as? KaNamedFunctionSymbol ?: return null
+
+            //overriding function
+            if (ownerFunction.isOverride)
+                ownerFunction.allOverriddenSymbols.firstNotNullOfOrNull { it.findMatchingParameterWithDefaultValue() }
+            else null
+        }
+    }
 
     @OptIn(KaExperimentalApi::class) // due to `KaPropertySymbol.initializer`
     private fun KaPropertySymbol.getDefaultValue(): Expression? =

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

@@ -8,8 +8,13 @@ import org.jetbrains.dokka.links.*
 import org.jetbrains.kotlin.analysis.api.KaSession
 import org.jetbrains.kotlin.analysis.api.types.*
 
-internal fun KaSession.getTypeReferenceFrom(type: KaType): TypeReference =
-    getTypeReferenceFromPossiblyRecursive(type, emptyList())
+internal fun KaSession.getTypeReferenceFrom(type: KaType, isVararg: Boolean = false): TypeReference {
+    val typeReference = getTypeReferenceFromPossiblyRecursive(type, emptyList())
+    return when {
+        isVararg -> Vararg(typeReference)
+        else -> typeReference
+    }
+}
 
 
 // see `deep recursive typebound #1342` test

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

@@ -665,6 +665,17 @@ public abstract class org/jetbrains/dokka/links/TypeReference {
 public final class org/jetbrains/dokka/links/TypeReference$Companion {
 }
 
+public final class org/jetbrains/dokka/links/Vararg : org/jetbrains/dokka/links/TypeReference {
+	public fun <init> (Lorg/jetbrains/dokka/links/TypeReference;)V
+	public final fun component1 ()Lorg/jetbrains/dokka/links/TypeReference;
+	public final fun copy (Lorg/jetbrains/dokka/links/TypeReference;)Lorg/jetbrains/dokka/links/Vararg;
+	public static synthetic fun copy$default (Lorg/jetbrains/dokka/links/Vararg;Lorg/jetbrains/dokka/links/TypeReference;ILjava/lang/Object;)Lorg/jetbrains/dokka/links/Vararg;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getElementType ()Lorg/jetbrains/dokka/links/TypeReference;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
 public final class org/jetbrains/dokka/model/ActualTypealias : org/jetbrains/dokka/model/properties/ExtraProperty {
 	public static final field Companion Lorg/jetbrains/dokka/model/ActualTypealias$Companion;
 	public fun <init> (Lorg/jetbrains/dokka/model/DTypeAlias;)V

dokka-subprojects/core/api/dokka-core.api

@@ -146,6 +146,10 @@ public data class Nullable(val wrapped: TypeReference) : TypeReference() {
     override fun toString(): String = "$wrapped?"
 }
 
+public data class Vararg(val elementType: TypeReference) : TypeReference() {
+    override fun toString(): String = "vararg($elementType)"
+}
+
 public object StarProjection : TypeReference() {
     override fun toString(): String = "*"
 }

dokka-subprojects/core/src/main/kotlin/org/jetbrains/dokka/links/DRI.kt

@@ -64,10 +64,10 @@ public open class JavadocExternalLocationProvider(
             is StarProjection -> "?"
 
             // TODO #3502
-            is TypeConstructor -> fullyQualifiedName +
-                    (if (params.isNotEmpty()) "[${params.joinToString(",") { it.toJavadocURL() }}]" else "")
+            is TypeConstructor -> fullyQualifiedName
             is TypeParam -> toString()
             is RecursiveType -> "^".repeat(rank + 1)
+            is Vararg -> "${elementType.toJavadocURL()}..."
         }
     }
 }