From 02f30b142aa467d3a24cc52a1fe3f2fed7ea1e33 Mon Sep 17 00:00:00 2001 From: Ignat Beresnev Date: Thu, 31 Aug 2023 20:16:01 +0200 Subject: Enable explicit API mode (#3139) --- core/src/main/kotlin/ConfigurationJsonUtils.kt | 16 +- core/src/main/kotlin/CoreExtensions.kt | 30 ++- core/src/main/kotlin/DokkaBootstrap.kt | 6 +- core/src/main/kotlin/DokkaBootstrapImpl.kt | 22 +- core/src/main/kotlin/DokkaException.kt | 2 +- core/src/main/kotlin/DokkaGenerator.kt | 40 ++-- core/src/main/kotlin/DokkaVersion.kt | 4 +- core/src/main/kotlin/configuration.kt | 211 +++++++++--------- core/src/main/kotlin/defaultConfiguration.kt | 19 +- core/src/main/kotlin/defaultExternalLinks.kt | 8 +- core/src/main/kotlin/generation/Generation.kt | 10 +- core/src/main/kotlin/links/DRI.kt | 82 +++---- core/src/main/kotlin/model/CompositeSourceSetID.kt | 6 +- core/src/main/kotlin/model/Documentable.kt | 238 +++++++++++---------- core/src/main/kotlin/model/JvmField.kt | 8 +- core/src/main/kotlin/model/WithChildren.kt | 30 +-- core/src/main/kotlin/model/additionalExtras.kt | 68 +++--- core/src/main/kotlin/model/ancestryNode.kt | 4 +- core/src/main/kotlin/model/classKinds.kt | 6 +- core/src/main/kotlin/model/defaultValues.kt | 23 +- core/src/main/kotlin/model/doc/DocTag.kt | 163 +++++++------- .../src/main/kotlin/model/doc/DocumentationNode.kt | 2 +- core/src/main/kotlin/model/doc/TagWrapper.kt | 39 ++-- .../main/kotlin/model/documentableProperties.kt | 34 +-- core/src/main/kotlin/model/documentableUtils.kt | 8 +- core/src/main/kotlin/model/extraModifiers.kt | 58 ++--- core/src/main/kotlin/model/jvmName.kt | 4 +- .../kotlin/model/properties/PropertyContainer.kt | 31 +-- .../src/main/kotlin/model/properties/properties.kt | 32 ++- core/src/main/kotlin/pages/ContentNodes.kt | 86 ++++---- core/src/main/kotlin/pages/PageNodes.kt | 48 +++-- core/src/main/kotlin/pages/Pages.kt | 10 +- core/src/main/kotlin/pages/RendererSpecificPage.kt | 37 ++-- .../src/main/kotlin/pages/contentNodeProperties.kt | 17 +- core/src/main/kotlin/pages/utils.kt | 4 +- .../main/kotlin/plugability/DefaultExtensions.kt | 4 - core/src/main/kotlin/plugability/DokkaContext.kt | 24 +-- .../src/main/kotlin/plugability/DokkaJavaPlugin.kt | 34 +-- core/src/main/kotlin/plugability/DokkaPlugin.kt | 51 +++-- core/src/main/kotlin/plugability/extensions.kt | 75 ++++--- core/src/main/kotlin/renderers/PostAction.kt | 2 +- core/src/main/kotlin/renderers/Renderer.kt | 4 +- .../documentation/DocumentableMerger.kt | 5 +- .../documentation/DocumentableToPageTranslator.kt | 5 +- .../documentation/DocumentableTransformer.kt | 4 +- .../PreMergeDocumentableTransformer.kt | 15 +- .../main/kotlin/transformers/pages/PageCreator.kt | 8 +- .../kotlin/transformers/pages/PageTransformer.kt | 4 +- .../transformers/pages/PageTransformerBuilders.kt | 17 +- .../sources/AsyncSourceToDocumentableTranslator.kt | 4 +- .../sources/SourceToDocumentableTranslator.kt | 4 +- core/src/main/kotlin/utilities/Collections.kt | 4 +- core/src/main/kotlin/utilities/DokkaLogging.kt | 31 +-- core/src/main/kotlin/utilities/Html.kt | 6 +- .../utilities/SelfRepresentingSingletonSet.kt | 2 +- core/src/main/kotlin/utilities/ServiceLocator.kt | 14 +- core/src/main/kotlin/utilities/Uri.kt | 2 +- .../main/kotlin/utilities/associateWithNotNull.kt | 2 +- core/src/main/kotlin/utilities/cast.kt | 2 +- .../utilities/parallelCollectionOperations.kt | 6 +- .../main/kotlin/validity/PreGenerationChecker.kt | 9 +- 61 files changed, 917 insertions(+), 827 deletions(-) delete mode 100644 core/src/main/kotlin/plugability/DefaultExtensions.kt (limited to 'core/src') diff --git a/core/src/main/kotlin/ConfigurationJsonUtils.kt b/core/src/main/kotlin/ConfigurationJsonUtils.kt index 9e03b906..e693f4ef 100644 --- a/core/src/main/kotlin/ConfigurationJsonUtils.kt +++ b/core/src/main/kotlin/ConfigurationJsonUtils.kt @@ -9,15 +9,15 @@ import org.jetbrains.dokka.utilities.parseJson import org.jetbrains.dokka.utilities.serializeAsCompactJson import org.jetbrains.dokka.utilities.serializeAsPrettyJson -fun DokkaConfigurationImpl(json: String): DokkaConfigurationImpl = parseJson(json) +public fun DokkaConfigurationImpl(json: String): DokkaConfigurationImpl = parseJson(json) -fun GlobalDokkaConfiguration(json: String): GlobalDokkaConfiguration = parseJson(json) +public fun GlobalDokkaConfiguration(json: String): GlobalDokkaConfiguration = parseJson(json) @Deprecated("Renamed to better distinguish between compact/pretty prints", ReplaceWith("this.toCompactJsonString()")) -fun DokkaConfiguration.toJsonString(): String = this.toCompactJsonString() +public fun DokkaConfiguration.toJsonString(): String = this.toCompactJsonString() @Deprecated("Renamed to better distinguish between compact/pretty prints", ReplaceWith("this.toCompactJsonString()")) -fun T.toJsonString(): String = this.toCompactJsonString() +public fun T.toJsonString(): String = this.toCompactJsonString() /** * Serializes [DokkaConfiguration] as a machine-readable and compact JSON string. @@ -25,7 +25,7 @@ fun T.toJsonString(): String = this.toCompactJsonString( * The returned string is not very human friendly as it will be difficult to parse by eyes due to it * being compact and in one line. If you want to show the output to a human being, see [toPrettyJsonString]. */ -fun DokkaConfiguration.toCompactJsonString(): String = serializeAsCompactJson(this) +public fun DokkaConfiguration.toCompactJsonString(): String = serializeAsCompactJson(this) /** * Serializes [DokkaConfiguration] as a human-readable (pretty printed) JSON string. @@ -34,7 +34,7 @@ fun DokkaConfiguration.toCompactJsonString(): String = serializeAsCompactJson(th * desirable when passing this value between API consumers/producers. If you want * a machine-readable and compact json string, see [toCompactJsonString]. */ -fun DokkaConfiguration.toPrettyJsonString(): String = serializeAsPrettyJson(this) +public fun DokkaConfiguration.toPrettyJsonString(): String = serializeAsPrettyJson(this) /** * Serializes a [ConfigurableBlock] as a machine-readable and compact JSON string. @@ -42,7 +42,7 @@ fun DokkaConfiguration.toPrettyJsonString(): String = serializeAsPrettyJson(this * The returned string is not very human friendly as it will be difficult to parse by eyes due to it * being compact and in one line. If you want to show the output to a human being, see [toPrettyJsonString]. */ -fun T.toCompactJsonString(): String = serializeAsCompactJson(this) +public fun T.toCompactJsonString(): String = serializeAsCompactJson(this) /** * Serializes a [ConfigurableBlock] as a human-readable (pretty printed) JSON string. @@ -51,4 +51,4 @@ fun T.toCompactJsonString(): String = serializeAsCompact * desirable when passing this value between API consumers/producers. If you want * a machine-readable and compact json string, see [toCompactJsonString]. */ -fun T.toPrettyJsonString(): String = serializeAsCompactJson(this) +public fun T.toPrettyJsonString(): String = serializeAsCompactJson(this) diff --git a/core/src/main/kotlin/CoreExtensions.kt b/core/src/main/kotlin/CoreExtensions.kt index d689d102..ca2504e2 100644 --- a/core/src/main/kotlin/CoreExtensions.kt +++ b/core/src/main/kotlin/CoreExtensions.kt @@ -16,17 +16,25 @@ import org.jetbrains.dokka.transformers.sources.SourceToDocumentableTranslator import org.jetbrains.dokka.validity.PreGenerationChecker import kotlin.reflect.KProperty -object CoreExtensions { - - val preGenerationCheck by coreExtensionPoint() - val generation by coreExtensionPoint() - val sourceToDocumentableTranslator by coreExtensionPoint() - val documentableMerger by coreExtensionPoint() - val documentableTransformer by coreExtensionPoint() - val documentableToPageTranslator by coreExtensionPoint() - val pageTransformer by coreExtensionPoint() - val renderer by coreExtensionPoint() - val postActions by coreExtensionPoint() +public object CoreExtensions { + + public val preGenerationCheck: ExtensionPoint by coreExtensionPoint() + + public val generation: ExtensionPoint by coreExtensionPoint() + + public val sourceToDocumentableTranslator: ExtensionPoint by coreExtensionPoint() + + public val documentableMerger: ExtensionPoint by coreExtensionPoint() + + public val documentableTransformer: ExtensionPoint by coreExtensionPoint() + + public val documentableToPageTranslator: ExtensionPoint by coreExtensionPoint() + + public val pageTransformer: ExtensionPoint by coreExtensionPoint() + + public val renderer: ExtensionPoint by coreExtensionPoint() + + public val postActions: ExtensionPoint by coreExtensionPoint() private fun coreExtensionPoint() = object { operator fun provideDelegate(thisRef: CoreExtensions, property: KProperty<*>): Lazy> = diff --git a/core/src/main/kotlin/DokkaBootstrap.kt b/core/src/main/kotlin/DokkaBootstrap.kt index 13cc9ded..d3d82e39 100644 --- a/core/src/main/kotlin/DokkaBootstrap.kt +++ b/core/src/main/kotlin/DokkaBootstrap.kt @@ -6,10 +6,10 @@ package org.jetbrains.dokka import java.util.function.BiConsumer -interface DokkaBootstrap { +public interface DokkaBootstrap { @Throws(Throwable::class) - fun configure(serializedConfigurationJSON: String, logger: BiConsumer) + public fun configure(serializedConfigurationJSON: String, logger: BiConsumer) @Throws(Throwable::class) - fun generate() + public fun generate() } diff --git a/core/src/main/kotlin/DokkaBootstrapImpl.kt b/core/src/main/kotlin/DokkaBootstrapImpl.kt index c0af9a41..65f0ef72 100644 --- a/core/src/main/kotlin/DokkaBootstrapImpl.kt +++ b/core/src/main/kotlin/DokkaBootstrapImpl.kt @@ -13,9 +13,11 @@ import java.util.function.BiConsumer * Accessed with reflection */ @Suppress("unused") -class DokkaBootstrapImpl : DokkaBootstrap { +public class DokkaBootstrapImpl : DokkaBootstrap { - class DokkaProxyLogger(val consumer: BiConsumer) : DokkaLogger { + public class DokkaProxyLogger( + public val consumer: BiConsumer + ) : DokkaLogger { private val warningsCounter = AtomicInteger() private val errorsCounter = AtomicInteger() @@ -50,14 +52,18 @@ class DokkaBootstrapImpl : DokkaBootstrap { private lateinit var generator: DokkaGenerator - fun configure(logger: DokkaLogger, configuration: DokkaConfigurationImpl) { + public fun configure(logger: DokkaLogger, configuration: DokkaConfigurationImpl) { generator = DokkaGenerator(configuration, logger) } - override fun configure(serializedConfigurationJSON: String, logger: BiConsumer) = configure( - DokkaProxyLogger(logger), - DokkaConfigurationImpl(serializedConfigurationJSON) - ) + override fun configure(serializedConfigurationJSON: String, logger: BiConsumer) { + configure( + DokkaProxyLogger(logger), + DokkaConfigurationImpl(serializedConfigurationJSON) + ) + } - override fun generate() = generator.generate() + override fun generate() { + generator.generate() + } } diff --git a/core/src/main/kotlin/DokkaException.kt b/core/src/main/kotlin/DokkaException.kt index cc487175..f16a2649 100644 --- a/core/src/main/kotlin/DokkaException.kt +++ b/core/src/main/kotlin/DokkaException.kt @@ -4,4 +4,4 @@ package org.jetbrains.dokka -open class DokkaException(message: String) : RuntimeException(message) +public open class DokkaException(message: String) : RuntimeException(message) diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt index 6132b92f..9ae3adb4 100644 --- a/core/src/main/kotlin/DokkaGenerator.kt +++ b/core/src/main/kotlin/DokkaGenerator.kt @@ -18,33 +18,35 @@ import org.jetbrains.dokka.utilities.DokkaLogger * * [generate] method has been split into submethods for test reasons */ -class DokkaGenerator( +public class DokkaGenerator( private val configuration: DokkaConfiguration, private val logger: DokkaLogger ) { - fun generate() = timed(logger) { - report("Initializing plugins") - val context = initializePlugins(configuration, logger) + public fun generate() { + timed(logger) { + report("Initializing plugins") + val context = initializePlugins(configuration, logger) - runCatching { - context.single(CoreExtensions.generation).run { - logger.progress("Dokka is performing: $generationName") - generate() + runCatching { + context.single(CoreExtensions.generation).run { + logger.progress("Dokka is performing: $generationName") + generate() + } + }.exceptionOrNull()?.let { e -> + finalizeCoroutines() + throw e } - }.exceptionOrNull()?.let { e -> - finalizeCoroutines() - throw e - } - finalizeCoroutines() - }.dump("\n\n === TIME MEASUREMENT ===\n") + finalizeCoroutines() + }.dump("\n\n === TIME MEASUREMENT ===\n") + } - fun initializePlugins( + public fun initializePlugins( configuration: DokkaConfiguration, logger: DokkaLogger, additionalPlugins: List = emptyList() - ) = DokkaContext.create(configuration, logger, additionalPlugins) + ): DokkaContext = DokkaContext.create(configuration, logger, additionalPlugins) @OptIn(DelicateCoroutinesApi::class) private fun finalizeCoroutines() { @@ -54,15 +56,15 @@ class DokkaGenerator( } } -class Timer internal constructor(startTime: Long, private val logger: DokkaLogger?) { +public class Timer internal constructor(startTime: Long, private val logger: DokkaLogger?) { private val steps = mutableListOf("" to startTime) - fun report(name: String) { + public fun report(name: String) { logger?.progress(name) steps += (name to System.currentTimeMillis()) } - fun dump(prefix: String = "") { + public fun dump(prefix: String = "") { logger?.info(prefix) val namePad = steps.map { it.first.length }.maxOrNull() ?: 0 val timePad = steps.windowed(2).map { (p1, p2) -> p2.second - p1.second }.maxOrNull()?.toString()?.length ?: 0 diff --git a/core/src/main/kotlin/DokkaVersion.kt b/core/src/main/kotlin/DokkaVersion.kt index 37ce77ba..d846988b 100644 --- a/core/src/main/kotlin/DokkaVersion.kt +++ b/core/src/main/kotlin/DokkaVersion.kt @@ -6,8 +6,8 @@ package org.jetbrains.dokka import java.util.* -object DokkaVersion { - val version: String by lazy { +public object DokkaVersion { + public val version: String by lazy { javaClass.getResourceAsStream("/META-INF/dokka/dokka-version.properties").use { stream -> Properties().apply { load(stream) }.getProperty("dokka-version") } diff --git a/core/src/main/kotlin/configuration.kt b/core/src/main/kotlin/configuration.kt index 9cbc6ea2..65035d04 100644 --- a/core/src/main/kotlin/configuration.kt +++ b/core/src/main/kotlin/configuration.kt @@ -9,53 +9,55 @@ import java.io.File import java.io.Serializable import java.net.URL -object DokkaDefaults { - val moduleName: String = "root" - val moduleVersion: String? = null - val outputDir = File("./dokka") - const val failOnWarning: Boolean = false - const val suppressObviousFunctions = true - const val suppressInheritedMembers = false - const val offlineMode: Boolean = false +public object DokkaDefaults { + public val moduleName: String = "root" + public val moduleVersion: String? = null + public val outputDir: File = File("./dokka") + public const val failOnWarning: Boolean = false + public const val suppressObviousFunctions: Boolean = true + public const val suppressInheritedMembers: Boolean = false + public const val offlineMode: Boolean = false - const val sourceSetDisplayName = "JVM" - const val sourceSetName = "main" - val analysisPlatform: Platform = Platform.DEFAULT + public const val sourceSetDisplayName: String = "JVM" + public const val sourceSetName: String = "main" + public val analysisPlatform: Platform = Platform.DEFAULT - const val suppress: Boolean = false - const val suppressGeneratedFiles: Boolean = true + public const val suppress: Boolean = false + public const val suppressGeneratedFiles: Boolean = true - const val skipEmptyPackages: Boolean = true - const val skipDeprecated: Boolean = false + public const val skipEmptyPackages: Boolean = true + public const val skipDeprecated: Boolean = false - const val reportUndocumented: Boolean = false + public const val reportUndocumented: Boolean = false - const val noStdlibLink: Boolean = false - const val noAndroidSdkLink: Boolean = false - const val noJdkLink: Boolean = false - const val jdkVersion: Int = 8 + public const val noStdlibLink: Boolean = false + public const val noAndroidSdkLink: Boolean = false + public const val noJdkLink: Boolean = false + public const val jdkVersion: Int = 8 - const val includeNonPublic: Boolean = false - val documentedVisibilities: Set = setOf(DokkaConfiguration.Visibility.PUBLIC) + public const val includeNonPublic: Boolean = false + public val documentedVisibilities: Set = setOf(DokkaConfiguration.Visibility.PUBLIC) - val pluginsConfiguration = mutableListOf() + public val pluginsConfiguration: List = mutableListOf() - const val delayTemplateSubstitution: Boolean = false + public const val delayTemplateSubstitution: Boolean = false - val cacheRoot: File? = null + public val cacheRoot: File? = null } -enum class Platform(val key: String) { +public enum class Platform( + public val key: String +) { jvm("jvm"), js("js"), wasm("wasm"), native("native"), common("common"); - companion object { - val DEFAULT = jvm + public companion object { + public val DEFAULT: Platform = jvm - fun fromString(key: String): Platform { + public fun fromString(key: String): Platform { return when (key.toLowerCase()) { jvm.key -> jvm js.key -> js @@ -70,14 +72,13 @@ enum class Platform(val key: String) { } } -fun interface DokkaConfigurationBuilder { - fun build(): T +public fun interface DokkaConfigurationBuilder { + public fun build(): T } -fun Iterable>.build(): List = this.map { it.build() } +public fun Iterable>.build(): List = this.map { it.build() } - -data class DokkaSourceSetID( +public data class DokkaSourceSetID( /** * Unique identifier of the scope that this source set is placed in. * Each scope provide only unique source set names. @@ -102,13 +103,13 @@ data class DokkaSourceSetID( * * @see [apply] to learn how to apply global configuration */ -data class GlobalDokkaConfiguration( +public data class GlobalDokkaConfiguration( val perPackageOptions: List?, val externalDocumentationLinks: List?, val sourceLinks: List? ) -fun DokkaConfiguration.apply(globals: GlobalDokkaConfiguration): DokkaConfiguration = this.apply { +public fun DokkaConfiguration.apply(globals: GlobalDokkaConfiguration): DokkaConfiguration = this.apply { sourceSets.forEach { it.perPackageOptions.cast>() .addAll(globals.perPackageOptions ?: emptyList()) @@ -124,21 +125,21 @@ fun DokkaConfiguration.apply(globals: GlobalDokkaConfiguration): DokkaConfigurat } } -interface DokkaConfiguration : Serializable { - val moduleName: String - val moduleVersion: String? - val outputDir: File - val cacheRoot: File? - val offlineMode: Boolean - val failOnWarning: Boolean - val sourceSets: List - val modules: List - val pluginsClasspath: List - val pluginsConfiguration: List - val delayTemplateSubstitution: Boolean - val suppressObviousFunctions: Boolean - val includes: Set - val suppressInheritedMembers: Boolean +public interface DokkaConfiguration : Serializable { + public val moduleName: String + public val moduleVersion: String? + public val outputDir: File + public val cacheRoot: File? + public val offlineMode: Boolean + public val failOnWarning: Boolean + public val sourceSets: List + public val modules: List + public val pluginsClasspath: List + public val pluginsConfiguration: List + public val delayTemplateSubstitution: Boolean + public val suppressObviousFunctions: Boolean + public val includes: Set + public val suppressInheritedMembers: Boolean /** * Whether coroutines dispatchers should be shutdown after @@ -157,46 +158,46 @@ interface DokkaConfiguration : Serializable { * and closing it down will leave the build in an inoperable state. * One such example is unit tests, for which finalization should be disabled. */ - val finalizeCoroutines: Boolean + public val finalizeCoroutines: Boolean - enum class SerializationFormat : Serializable { + public enum class SerializationFormat : Serializable { JSON, XML } - interface PluginConfiguration : Serializable { - val fqPluginName: String - val serializationFormat: SerializationFormat - val values: String + public interface PluginConfiguration : Serializable { + public val fqPluginName: String + public val serializationFormat: SerializationFormat + public val values: String } - interface DokkaSourceSet : Serializable { - val sourceSetID: DokkaSourceSetID - val displayName: String - val classpath: List - val sourceRoots: Set - val dependentSourceSets: Set - val samples: Set - val includes: Set + public interface DokkaSourceSet : Serializable { + public val sourceSetID: DokkaSourceSetID + public val displayName: String + public val classpath: List + public val sourceRoots: Set + public val dependentSourceSets: Set + public val samples: Set + public val includes: Set @Deprecated(message = "Use [documentedVisibilities] property for a more flexible control over documented visibilities") - val includeNonPublic: Boolean - val reportUndocumented: Boolean - val skipEmptyPackages: Boolean - val skipDeprecated: Boolean - val jdkVersion: Int - val sourceLinks: Set - val perPackageOptions: List - val externalDocumentationLinks: Set - val languageVersion: String? - val apiVersion: String? - val noStdlibLink: Boolean - val noJdkLink: Boolean - val suppressedFiles: Set - val analysisPlatform: Platform - val documentedVisibilities: Set + public val includeNonPublic: Boolean + public val reportUndocumented: Boolean + public val skipEmptyPackages: Boolean + public val skipDeprecated: Boolean + public val jdkVersion: Int + public val sourceLinks: Set + public val perPackageOptions: List + public val externalDocumentationLinks: Set + public val languageVersion: String? + public val apiVersion: String? + public val noStdlibLink: Boolean + public val noJdkLink: Boolean + public val suppressedFiles: Set + public val analysisPlatform: Platform + public val documentedVisibilities: Set } - enum class Visibility { + public enum class Visibility { /** * `public` modifier for Java, default visibility for Kotlin */ @@ -222,45 +223,45 @@ interface DokkaConfiguration : Serializable { */ PACKAGE; - companion object { - fun fromString(value: String) = valueOf(value.toUpperCase()) + public companion object { + public fun fromString(value: String): Visibility = valueOf(value.toUpperCase()) } } - interface SourceLinkDefinition : Serializable { - val localDirectory: String - val remoteUrl: URL - val remoteLineSuffix: String? + public interface SourceLinkDefinition : Serializable { + public val localDirectory: String + public val remoteUrl: URL + public val remoteLineSuffix: String? } - interface DokkaModuleDescription : Serializable { - val name: String - val relativePathToOutputDirectory: File - val sourceOutputDirectory: File - val includes: Set + public interface DokkaModuleDescription : Serializable { + public val name: String + public val relativePathToOutputDirectory: File + public val sourceOutputDirectory: File + public val includes: Set } - interface PackageOptions : Serializable { - val matchingRegex: String + public interface PackageOptions : Serializable { + public val matchingRegex: String @Deprecated("Use [documentedVisibilities] property for a more flexible control over documented visibilities") - val includeNonPublic: Boolean - val reportUndocumented: Boolean? - val skipDeprecated: Boolean - val suppress: Boolean - val documentedVisibilities: Set + public val includeNonPublic: Boolean + public val reportUndocumented: Boolean? + public val skipDeprecated: Boolean + public val suppress: Boolean + public val documentedVisibilities: Set } - interface ExternalDocumentationLink : Serializable { - val url: URL - val packageListUrl: URL + public interface ExternalDocumentationLink : Serializable { + public val url: URL + public val packageListUrl: URL - companion object + public companion object } } @Suppress("FunctionName") -fun ExternalDocumentationLink( +public fun ExternalDocumentationLink( url: URL? = null, packageListUrl: URL? = null ): ExternalDocumentationLinkImpl { @@ -273,7 +274,7 @@ fun ExternalDocumentationLink( } @Suppress("FunctionName") -fun ExternalDocumentationLink( +public fun ExternalDocumentationLink( url: String, packageListUrl: String? = null ): ExternalDocumentationLinkImpl = ExternalDocumentationLink(url.let(::URL), packageListUrl?.let(::URL)) diff --git a/core/src/main/kotlin/defaultConfiguration.kt b/core/src/main/kotlin/defaultConfiguration.kt index 2ea5e0ef..f858d8c0 100644 --- a/core/src/main/kotlin/defaultConfiguration.kt +++ b/core/src/main/kotlin/defaultConfiguration.kt @@ -8,7 +8,7 @@ import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet import java.io.File import java.net.URL -data class DokkaConfigurationImpl( +public data class DokkaConfigurationImpl( override val moduleName: String = DokkaDefaults.moduleName, override val moduleVersion: String? = DokkaDefaults.moduleVersion, override val outputDir: File = DokkaDefaults.outputDir, @@ -26,14 +26,14 @@ data class DokkaConfigurationImpl( override val finalizeCoroutines: Boolean = true, ) : DokkaConfiguration -data class PluginConfigurationImpl( +public data class PluginConfigurationImpl( override val fqPluginName: String, override val serializationFormat: DokkaConfiguration.SerializationFormat, override val values: String ) : DokkaConfiguration.PluginConfiguration -data class DokkaSourceSetImpl( +public data class DokkaSourceSetImpl( override val displayName: String = DokkaDefaults.sourceSetDisplayName, override val sourceSetID: DokkaSourceSetID, override val classpath: List = emptyList(), @@ -59,20 +59,21 @@ data class DokkaSourceSetImpl( override val documentedVisibilities: Set = DokkaDefaults.documentedVisibilities, ) : DokkaSourceSet -data class DokkaModuleDescriptionImpl( +public data class DokkaModuleDescriptionImpl( override val name: String, override val relativePathToOutputDirectory: File, override val includes: Set, override val sourceOutputDirectory: File ) : DokkaConfiguration.DokkaModuleDescription -data class SourceLinkDefinitionImpl( +public data class SourceLinkDefinitionImpl( override val localDirectory: String, override val remoteUrl: URL, override val remoteLineSuffix: String?, ) : DokkaConfiguration.SourceLinkDefinition { - companion object { - fun parseSourceLinkDefinition(srcLink: String): SourceLinkDefinitionImpl { + + public companion object { + public fun parseSourceLinkDefinition(srcLink: String): SourceLinkDefinitionImpl { val (path, urlAndLine) = srcLink.split('=') return SourceLinkDefinitionImpl( localDirectory = File(path).canonicalPath, @@ -82,7 +83,7 @@ data class SourceLinkDefinitionImpl( } } -data class PackageOptionsImpl( +public data class PackageOptionsImpl( override val matchingRegex: String, @Deprecated("Use [documentedVisibilities] property for a more flexible control over documented visibilities") override val includeNonPublic: Boolean, @@ -93,7 +94,7 @@ data class PackageOptionsImpl( ) : DokkaConfiguration.PackageOptions -data class ExternalDocumentationLinkImpl( +public data class ExternalDocumentationLinkImpl( override val url: URL, override val packageListUrl: URL, ) : DokkaConfiguration.ExternalDocumentationLink diff --git a/core/src/main/kotlin/defaultExternalLinks.kt b/core/src/main/kotlin/defaultExternalLinks.kt index 8d3b9655..26e3e0ae 100644 --- a/core/src/main/kotlin/defaultExternalLinks.kt +++ b/core/src/main/kotlin/defaultExternalLinks.kt @@ -8,7 +8,7 @@ import org.jetbrains.dokka.DokkaConfiguration.ExternalDocumentationLink import java.net.URL -fun ExternalDocumentationLink.Companion.jdk(jdkVersion: Int): ExternalDocumentationLinkImpl = +public fun ExternalDocumentationLink.Companion.jdk(jdkVersion: Int): ExternalDocumentationLinkImpl = ExternalDocumentationLink( url = if (jdkVersion < 11) "https://docs.oracle.com/javase/${jdkVersion}/docs/api/" @@ -19,15 +19,15 @@ fun ExternalDocumentationLink.Companion.jdk(jdkVersion: Int): ExternalDocumentat ) -fun ExternalDocumentationLink.Companion.kotlinStdlib(): ExternalDocumentationLinkImpl = +public fun ExternalDocumentationLink.Companion.kotlinStdlib(): ExternalDocumentationLinkImpl = ExternalDocumentationLink("https://kotlinlang.org/api/latest/jvm/stdlib/") -fun ExternalDocumentationLink.Companion.androidSdk(): ExternalDocumentationLinkImpl = +public fun ExternalDocumentationLink.Companion.androidSdk(): ExternalDocumentationLinkImpl = ExternalDocumentationLink("https://developer.android.com/reference/kotlin/") -fun ExternalDocumentationLink.Companion.androidX(): ExternalDocumentationLinkImpl = ExternalDocumentationLink( +public fun ExternalDocumentationLink.Companion.androidX(): ExternalDocumentationLinkImpl = ExternalDocumentationLink( url = URL("https://developer.android.com/reference/kotlin/"), packageListUrl = URL("https://developer.android.com/reference/kotlin/androidx/package-list") ) diff --git a/core/src/main/kotlin/generation/Generation.kt b/core/src/main/kotlin/generation/Generation.kt index 185b00f8..9f14912f 100644 --- a/core/src/main/kotlin/generation/Generation.kt +++ b/core/src/main/kotlin/generation/Generation.kt @@ -6,14 +6,14 @@ package org.jetbrains.dokka.generation import org.jetbrains.dokka.Timer -interface Generation { - fun Timer.generate() - val generationName: String +public interface Generation { + public fun Timer.generate() + public val generationName: String } // This needs to be public for now but in the future it should be replaced with system of checks provided by EP -fun exitGenerationGracefully(reason: String): Nothing { +public fun exitGenerationGracefully(reason: String): Nothing { throw GracefulGenerationExit(reason) } -class GracefulGenerationExit(val reason: String) : Throwable() +public class GracefulGenerationExit(public val reason: String) : Throwable() diff --git a/core/src/main/kotlin/links/DRI.kt b/core/src/main/kotlin/links/DRI.kt index bcd0198b..180d9eb8 100644 --- a/core/src/main/kotlin/links/DRI.kt +++ b/core/src/main/kotlin/links/DRI.kt @@ -12,7 +12,7 @@ import com.fasterxml.jackson.module.kotlin.readValue /** * [DRI] stands for DokkaResourceIdentifier */ -data class DRI( +public data class DRI( val packageName: String? = null, val classNames: String? = null, val callable: Callable? = null, @@ -23,47 +23,47 @@ data class DRI( "${packageName.orEmpty()}/${classNames.orEmpty()}/${callable?.name.orEmpty()}/${callable?.signature() .orEmpty()}/$target/${extra.orEmpty()}" - companion object { - val topLevel = DRI() - + public companion object { + public val topLevel: DRI = DRI() } } -object EnumEntryDRIExtra: DRIExtraProperty() +public object EnumEntryDRIExtra: DRIExtraProperty() -abstract class DRIExtraProperty { - val key: String = this::class.qualifiedName +public abstract class DRIExtraProperty { + public val key: String = this::class.qualifiedName ?: (this.javaClass.let { it.`package`.name + "." + it.simpleName.ifEmpty { "anonymous" } }) } -class DRIExtraContainer(val data: String? = null) { - val map: MutableMap = if (data != null) OBJECT_MAPPER.readValue(data) else mutableMapOf() - inline operator fun get(prop: DRIExtraProperty): T? = +public class DRIExtraContainer(public val data: String? = null) { + public val map: MutableMap = if (data != null) OBJECT_MAPPER.readValue(data) else mutableMapOf() + public inline operator fun get(prop: DRIExtraProperty): T? = map[prop.key]?.let { prop as? T } - inline operator fun set(prop: DRIExtraProperty, value: T) = - value.also { map[prop.key] = it as Any } + public inline operator fun set(prop: DRIExtraProperty, value: T) { + map[prop.key] = value as Any + } - fun encode(): String = OBJECT_MAPPER.writeValueAsString(map) + public fun encode(): String = OBJECT_MAPPER.writeValueAsString(map) private companion object { private val OBJECT_MAPPER = ObjectMapper() } } -val DriOfUnit = DRI("kotlin", "Unit") -val DriOfAny = DRI("kotlin", "Any") +public val DriOfUnit: DRI = DRI("kotlin", "Unit") +public val DriOfAny: DRI = DRI("kotlin", "Any") -fun DRI.withClass(name: String) = copy(classNames = if (classNames.isNullOrBlank()) name else "$classNames.$name") +public fun DRI.withClass(name: String): DRI = copy(classNames = if (classNames.isNullOrBlank()) name else "$classNames.$name") -fun DRI.withTargetToDeclaration() = copy(target = PointingToDeclaration) +public fun DRI.withTargetToDeclaration(): DRI = copy(target = PointingToDeclaration) -fun DRI.withEnumEntryExtra() = copy( +public fun DRI.withEnumEntryExtra(): DRI = copy( extra = DRIExtraContainer(this.extra).also { it[EnumEntryDRIExtra] = EnumEntryDRIExtra }.encode() ) -val DRI.parent: DRI +public val DRI.parent: DRI get() = when { extra != null -> when { DRIExtraContainer(extra)[EnumEntryDRIExtra] != null -> copy( @@ -78,68 +78,68 @@ val DRI.parent: DRI else -> DRI.topLevel } -val DRI.sureClassNames +public val DRI.sureClassNames: String get() = classNames ?: throw IllegalStateException("Malformed DRI. It requires classNames in this context.") -data class Callable( +public data class Callable( val name: String, val receiver: TypeReference? = null, val params: List ) { - fun signature() = "${receiver?.toString().orEmpty()}#${params.joinToString("#")}" + public fun signature(): String = "${receiver?.toString().orEmpty()}#${params.joinToString("#")}" - companion object + public companion object } @JsonTypeInfo(use = CLASS) -sealed class TypeReference { - companion object +public sealed class TypeReference { + public companion object } -data class JavaClassReference(val name: String) : TypeReference() { +public data class JavaClassReference(val name: String) : TypeReference() { override fun toString(): String = name } -data class TypeParam(val bounds: List) : TypeReference() +public data class TypeParam(val bounds: List) : TypeReference() -data class TypeConstructor( +public data class TypeConstructor( val fullyQualifiedName: String, val params: List ) : TypeReference() { - override fun toString() = fullyQualifiedName + + override fun toString(): String = fullyQualifiedName + (if (params.isNotEmpty()) "[${params.joinToString(",")}]" else "") } -data class RecursiveType(val rank: Int): TypeReference() { - override fun toString() = "^".repeat(rank + 1) +public data class RecursiveType(val rank: Int): TypeReference() { + override fun toString(): String = "^".repeat(rank + 1) } -data class Nullable(val wrapped: TypeReference) : TypeReference() { - override fun toString() = "$wrapped?" +public data class Nullable(val wrapped: TypeReference) : TypeReference() { + override fun toString(): String = "$wrapped?" } -object StarProjection : TypeReference() { - override fun toString() = "*" +public object StarProjection : TypeReference() { + override fun toString(): String = "*" } @JsonTypeInfo(use = CLASS) -sealed class DriTarget { +public sealed class DriTarget { override fun toString(): String = this.javaClass.simpleName - companion object + public companion object } -data class PointingToGenericParameters(val parameterIndex: Int) : DriTarget() { +public data class PointingToGenericParameters(val parameterIndex: Int) : DriTarget() { override fun toString(): String = "PointingToGenericParameters($parameterIndex)" } -object PointingToDeclaration : DriTarget() +public object PointingToDeclaration : DriTarget() -data class PointingToCallableParameters(val parameterIndex: Int) : DriTarget() { +public data class PointingToCallableParameters(val parameterIndex: Int) : DriTarget() { override fun toString(): String = "PointingToCallableParameters($parameterIndex)" } -fun DriTarget.nextTarget(): DriTarget = when (this) { +public fun DriTarget.nextTarget(): DriTarget = when (this) { is PointingToGenericParameters -> PointingToGenericParameters(this.parameterIndex + 1) is PointingToCallableParameters -> PointingToCallableParameters(this.parameterIndex + 1) else -> this diff --git a/core/src/main/kotlin/model/CompositeSourceSetID.kt b/core/src/main/kotlin/model/CompositeSourceSetID.kt index 36318633..af7d1a5d 100644 --- a/core/src/main/kotlin/model/CompositeSourceSetID.kt +++ b/core/src/main/kotlin/model/CompositeSourceSetID.kt @@ -32,15 +32,15 @@ public data class CompositeSourceSetID( public val all: Set = setOf(merged, *children.toTypedArray()) - operator fun contains(sourceSetId: DokkaSourceSetID): Boolean { + public operator fun contains(sourceSetId: DokkaSourceSetID): Boolean { return sourceSetId in all } - operator fun contains(sourceSet: DokkaConfiguration.DokkaSourceSet): Boolean { + public operator fun contains(sourceSet: DokkaConfiguration.DokkaSourceSet): Boolean { return sourceSet.sourceSetID in this } - operator fun plus(other: DokkaSourceSetID): CompositeSourceSetID { + public operator fun plus(other: DokkaSourceSetID): CompositeSourceSetID { return copy(children = children + other) } } diff --git a/core/src/main/kotlin/model/Documentable.kt b/core/src/main/kotlin/model/Documentable.kt index d96b051c..c6109f47 100644 --- a/core/src/main/kotlin/model/Documentable.kt +++ b/core/src/main/kotlin/model/Documentable.kt @@ -10,92 +10,95 @@ import org.jetbrains.dokka.model.doc.DocumentationNode import org.jetbrains.dokka.model.properties.PropertyContainer import org.jetbrains.dokka.model.properties.WithExtraProperties -interface AnnotationTarget +public interface AnnotationTarget -abstract class Documentable : WithChildren, +public abstract class Documentable : WithChildren, AnnotationTarget { - abstract val name: String? - abstract val dri: DRI - abstract val documentation: SourceSetDependent - abstract val sourceSets: Set - abstract val expectPresentInSet: DokkaSourceSet? + public abstract val name: String? + public abstract val dri: DRI + public abstract val documentation: SourceSetDependent + public abstract val sourceSets: Set + public abstract val expectPresentInSet: DokkaSourceSet? abstract override val children: List override fun toString(): String = "${javaClass.simpleName}($dri)" - override fun equals(other: Any?) = + override fun equals(other: Any?): Boolean = other is Documentable && this.dri == other.dri // TODO: https://github.com/Kotlin/dokka/pull/667#discussion_r382555806 - override fun hashCode() = dri.hashCode() + override fun hashCode(): Int = dri.hashCode() } -typealias SourceSetDependent = Map +public typealias SourceSetDependent = Map -interface WithSources { - val sources: SourceSetDependent +public interface WithSources { + public val sources: SourceSetDependent } -interface WithScope { - val functions: List - val properties: List - val classlikes: List +public interface WithScope { + public val functions: List + public val properties: List + public val classlikes: List } -interface WithVisibility { - val visibility: SourceSetDependent +public interface WithVisibility { + public val visibility: SourceSetDependent } -interface WithType { - val type: Bound +public interface WithType { + public val type: Bound } -interface WithAbstraction { - val modifier: SourceSetDependent +public interface WithAbstraction { + public val modifier: SourceSetDependent } -sealed class Modifier(val name: String) -sealed class KotlinModifier(name: String) : Modifier(name) { - object Abstract : KotlinModifier("abstract") - object Open : KotlinModifier("open") - object Final : KotlinModifier("final") - object Sealed : KotlinModifier("sealed") - object Empty : KotlinModifier("") +public sealed class Modifier( + public val name: String +) + +public sealed class KotlinModifier(name: String) : Modifier(name) { + public object Abstract : KotlinModifier("abstract") + public object Open : KotlinModifier("open") + public object Final : KotlinModifier("final") + public object Sealed : KotlinModifier("sealed") + public object Empty : KotlinModifier("") } -sealed class JavaModifier(name: String) : Modifier(name) { - object Abstract : JavaModifier("abstract") - object Final : JavaModifier("final") - object Empty : JavaModifier("") +public sealed class JavaModifier(name: String) : Modifier(name) { + public object Abstract : JavaModifier("abstract") + public object Final : JavaModifier("final") + public object Empty : JavaModifier("") } -interface WithCompanion { - val companion: DObject? +public interface WithCompanion { + public val companion: DObject? } -interface WithConstructors { - val constructors: List +public interface WithConstructors { + public val constructors: List } -interface WithGenerics { - val generics: List +public interface WithGenerics { + public val generics: List } -interface WithSupertypes { - val supertypes: SourceSetDependent> +public interface WithSupertypes { + public val supertypes: SourceSetDependent> } -interface WithIsExpectActual { - val isExpectActual: Boolean +public interface WithIsExpectActual { + public val isExpectActual: Boolean } -interface Callable : WithVisibility, WithType, WithAbstraction, WithSources, WithIsExpectActual { - val receiver: DParameter? +public interface Callable : WithVisibility, WithType, WithAbstraction, WithSources, WithIsExpectActual { + public val receiver: DParameter? } -sealed class DClasslike : Documentable(), WithScope, WithVisibility, WithSources, WithIsExpectActual +public sealed class DClasslike : Documentable(), WithScope, WithVisibility, WithSources, WithIsExpectActual -data class DModule( +public data class DModule( override val name: String, val packages: List, override val documentation: SourceSetDependent, @@ -107,10 +110,10 @@ data class DModule( override val children: List get() = packages - override fun withNewExtras(newExtras: PropertyContainer) = copy(extra = newExtras) + override fun withNewExtras(newExtras: PropertyContainer): DModule = copy(extra = newExtras) } -data class DPackage( +public data class DPackage( override val dri: DRI, override val functions: List, override val properties: List, @@ -134,10 +137,10 @@ data class DPackage( override val children: List = properties + functions + classlikes + typealiases - override fun withNewExtras(newExtras: PropertyContainer) = copy(extra = newExtras) + override fun withNewExtras(newExtras: PropertyContainer): DPackage = copy(extra = newExtras) } -data class DClass( +public data class DClass( override val dri: DRI, override val name: String, override val constructors: List, @@ -161,10 +164,10 @@ data class DClass( override val children: List get() = (functions + properties + classlikes + constructors) - override fun withNewExtras(newExtras: PropertyContainer) = copy(extra = newExtras) + override fun withNewExtras(newExtras: PropertyContainer): DClass = copy(extra = newExtras) } -data class DEnum( +public data class DEnum( override val dri: DRI, override val name: String, val entries: List, @@ -185,10 +188,10 @@ data class DEnum( override val children: List get() = (entries + functions + properties + classlikes + constructors) - override fun withNewExtras(newExtras: PropertyContainer) = copy(extra = newExtras) + override fun withNewExtras(newExtras: PropertyContainer): DEnum = copy(extra = newExtras) } -data class DEnumEntry( +public data class DEnumEntry( override val dri: DRI, override val name: String, override val documentation: SourceSetDependent, @@ -202,10 +205,10 @@ data class DEnumEntry( override val children: List get() = (functions + properties + classlikes) - override fun withNewExtras(newExtras: PropertyContainer) = copy(extra = newExtras) + override fun withNewExtras(newExtras: PropertyContainer): DEnumEntry = copy(extra = newExtras) } -data class DFunction( +public data class DFunction( override val dri: DRI, override val name: String, val isConstructor: Boolean, @@ -225,10 +228,10 @@ data class DFunction( override val children: List get() = parameters - override fun withNewExtras(newExtras: PropertyContainer) = copy(extra = newExtras) + override fun withNewExtras(newExtras: PropertyContainer): DFunction = copy(extra = newExtras) } -data class DInterface( +public data class DInterface( override val dri: DRI, override val name: String, override val documentation: SourceSetDependent, @@ -248,10 +251,10 @@ data class DInterface( override val children: List get() = (functions + properties + classlikes) - override fun withNewExtras(newExtras: PropertyContainer) = copy(extra = newExtras) + override fun withNewExtras(newExtras: PropertyContainer): DInterface = copy(extra = newExtras) } -data class DObject( +public data class DObject( override val name: String?, override val dri: DRI, override val documentation: SourceSetDependent, @@ -269,10 +272,10 @@ data class DObject( override val children: List get() = (functions + properties + classlikes) - override fun withNewExtras(newExtras: PropertyContainer) = copy(extra = newExtras) + override fun withNewExtras(newExtras: PropertyContainer): DObject = copy(extra = newExtras) } -data class DAnnotation( +public data class DAnnotation( override val name: String, override val dri: DRI, override val documentation: SourceSetDependent, @@ -292,10 +295,10 @@ data class DAnnotation( override val children: List get() = (functions + properties + classlikes + constructors) - override fun withNewExtras(newExtras: PropertyContainer) = copy(extra = newExtras) + override fun withNewExtras(newExtras: PropertyContainer): DAnnotation = copy(extra = newExtras) } -data class DProperty( +public data class DProperty( override val dri: DRI, override val name: String, override val documentation: SourceSetDependent, @@ -315,11 +318,11 @@ data class DProperty( override val children: List get() = emptyList() - override fun withNewExtras(newExtras: PropertyContainer) = copy(extra = newExtras) + override fun withNewExtras(newExtras: PropertyContainer): DProperty = copy(extra = newExtras) } // TODO: treat named Parameters and receivers differently -data class DParameter( +public data class DParameter( override val dri: DRI, override val name: String?, override val documentation: SourceSetDependent, @@ -331,10 +334,10 @@ data class DParameter( override val children: List get() = emptyList() - override fun withNewExtras(newExtras: PropertyContainer) = copy(extra = newExtras) + override fun withNewExtras(newExtras: PropertyContainer): DParameter = copy(extra = newExtras) } -data class DTypeParameter( +public data class DTypeParameter( val variantTypeParameter: Variance, override val documentation: SourceSetDependent, override val expectPresentInSet: DokkaSourceSet?, @@ -343,7 +346,7 @@ data class DTypeParameter( override val extra: PropertyContainer = PropertyContainer.empty() ) : Documentable(), WithExtraProperties { - constructor( + public constructor( dri: DRI, name: String, presentableName: String?, @@ -367,10 +370,10 @@ data class DTypeParameter( override val children: List get() = emptyList() - override fun withNewExtras(newExtras: PropertyContainer) = copy(extra = newExtras) + override fun withNewExtras(newExtras: PropertyContainer): DTypeParameter = copy(extra = newExtras) } -data class DTypeAlias( +public data class DTypeAlias( override val dri: DRI, override val name: String, override val type: Bound, @@ -386,12 +389,12 @@ data class DTypeAlias( override val children: List get() = emptyList() - override fun withNewExtras(newExtras: PropertyContainer) = copy(extra = newExtras) + override fun withNewExtras(newExtras: PropertyContainer): DTypeAlias = copy(extra = newExtras) } -sealed class Projection -sealed class Bound : Projection() -data class TypeParameter( +public sealed class Projection +public sealed class Bound : Projection() +public data class TypeParameter( val dri: DRI, val name: String, val presentableName: String? = null, @@ -401,13 +404,13 @@ data class TypeParameter( copy(extra = extra) } -sealed class TypeConstructor : Bound(), AnnotationTarget { - abstract val dri: DRI - abstract val projections: List - abstract val presentableName: String? +public sealed class TypeConstructor : Bound(), AnnotationTarget { + public abstract val dri: DRI + public abstract val projections: List + public abstract val presentableName: String? } -data class GenericTypeConstructor( +public data class GenericTypeConstructor( override val dri: DRI, override val projections: List, override val presentableName: String? = null, @@ -417,7 +420,7 @@ data class GenericTypeConstructor( copy(extra = newExtras) } -data class FunctionalTypeConstructor( +public data class FunctionalTypeConstructor( override val dri: DRI, override val projections: List, val isExtensionFunction: Boolean = false, @@ -430,7 +433,7 @@ data class FunctionalTypeConstructor( } // kotlin.annotation.AnnotationTarget.TYPEALIAS -data class TypeAliased( +public data class TypeAliased( val typeAlias: Bound, val inner: Bound, override val extra: PropertyContainer = PropertyContainer.empty() @@ -439,7 +442,7 @@ data class TypeAliased( copy(extra = newExtras) } -data class PrimitiveJavaType( +public data class PrimitiveJavaType( val name: String, override val extra: PropertyContainer = PropertyContainer.empty() ) : Bound(), AnnotationTarget, WithExtraProperties { @@ -447,13 +450,13 @@ data class PrimitiveJavaType( copy(extra = newExtras) } -data class JavaObject(override val extra: PropertyContainer = PropertyContainer.empty()) : +public data class JavaObject(override val extra: PropertyContainer = PropertyContainer.empty()) : Bound(), AnnotationTarget, WithExtraProperties { override fun withNewExtras(newExtras: PropertyContainer): JavaObject = copy(extra = newExtras) } -data class UnresolvedBound( +public data class UnresolvedBound( val name: String, override val extra: PropertyContainer = PropertyContainer.empty() ) : Bound(), AnnotationTarget, WithExtraProperties { @@ -462,66 +465,67 @@ data class UnresolvedBound( } // The following Projections are not AnnotationTargets; they cannot be annotated. -data class Nullable(val inner: Bound) : Bound() +public data class Nullable(val inner: Bound) : Bound() /** * It introduces [definitely non-nullable types](https://github.com/Kotlin/KEEP/blob/c72601cf35c1e95a541bb4b230edb474a6d1d1a8/proposals/definitely-non-nullable-types.md) */ -data class DefinitelyNonNullable(val inner: Bound) : Bound() +public data class DefinitelyNonNullable(val inner: Bound) : Bound() -sealed class Variance : Projection() { - abstract val inner: T +public sealed class Variance : Projection() { + public abstract val inner: T } -data class Covariance(override val inner: T) : Variance() { - override fun toString() = "out" +public data class Covariance(override val inner: T) : Variance() { + override fun toString(): String = "out" } -data class Contravariance(override val inner: T) : Variance() { - override fun toString() = "in" +public data class Contravariance(override val inner: T) : Variance() { + override fun toString(): String = "in" } -data class Invariance(override val inner: T) : Variance() { - override fun toString() = "" +public data class Invariance(override val inner: T) : Variance() { + override fun toString(): String = "" } -object Star : Projection() +public object Star : Projection() -object Void : Bound() -object Dynamic : Bound() +public object Void : Bound() +public object Dynamic : Bound() -fun Variance.withDri(dri: DRI) = when (this) { +public fun Variance.withDri(dri: DRI): Variance = when (this) { is Contravariance -> Contravariance(TypeParameter(dri, inner.name, inner.presentableName)) is Covariance -> Covariance(TypeParameter(dri, inner.name, inner.presentableName)) is Invariance -> Invariance(TypeParameter(dri, inner.name, inner.presentableName)) } -fun Documentable.dfs(predicate: (Documentable) -> Boolean): Documentable? = +public fun Documentable.dfs(predicate: (Documentable) -> Boolean): Documentable? = if (predicate(this)) { this } else { this.children.asSequence().mapNotNull { it.dfs(predicate) }.firstOrNull() } -sealed class Visibility(val name: String) -sealed class KotlinVisibility(name: String) : Visibility(name) { - object Public : KotlinVisibility("public") - object Private : KotlinVisibility("private") - object Protected : KotlinVisibility("protected") - object Internal : KotlinVisibility("internal") +public sealed class Visibility(public val name: String) + +public sealed class KotlinVisibility(name: String) : Visibility(name) { + public object Public : KotlinVisibility("public") + public object Private : KotlinVisibility("private") + public object Protected : KotlinVisibility("protected") + public object Internal : KotlinVisibility("internal") } -sealed class JavaVisibility(name: String) : Visibility(name) { - object Public : JavaVisibility("public") - object Private : JavaVisibility("private") - object Protected : JavaVisibility("protected") - object Default : JavaVisibility("") +public sealed class JavaVisibility(name: String) : Visibility(name) { + public object Public : JavaVisibility("public") + public object Private : JavaVisibility("private") + public object Protected : JavaVisibility("protected") + public object Default : JavaVisibility("") } -fun SourceSetDependent?.orEmpty(): SourceSetDependent = this ?: emptyMap() +public fun SourceSetDependent?.orEmpty(): SourceSetDependent = this ?: emptyMap() -interface DocumentableSource { - val path: String +public interface DocumentableSource { + public val path: String /** * Computes the first line number of the documentable's declaration/signature/identifier. @@ -530,7 +534,7 @@ interface DocumentableSource { * * May return null if the sources could not be found - for example, for synthetic/generated declarations. */ - fun computeLineNumber(): Int? + public fun computeLineNumber(): Int? } -data class TypeConstructorWithKind(val typeConstructor: TypeConstructor, val kind: ClassKind) +public data class TypeConstructorWithKind(val typeConstructor: TypeConstructor, val kind: ClassKind) diff --git a/core/src/main/kotlin/model/JvmField.kt b/core/src/main/kotlin/model/JvmField.kt index 38829ef5..a2b641c9 100644 --- a/core/src/main/kotlin/model/JvmField.kt +++ b/core/src/main/kotlin/model/JvmField.kt @@ -6,9 +6,9 @@ package org.jetbrains.dokka.model import org.jetbrains.dokka.links.DRI -const val JVM_FIELD_PACKAGE_NAME = "kotlin.jvm" -const val JVM_FIELD_CLASS_NAMES = "JvmField" +public const val JVM_FIELD_PACKAGE_NAME: String = "kotlin.jvm" +public const val JVM_FIELD_CLASS_NAMES: String = "JvmField" -fun DRI.isJvmField(): Boolean = packageName == JVM_FIELD_PACKAGE_NAME && classNames == JVM_FIELD_CLASS_NAMES +public fun DRI.isJvmField(): Boolean = packageName == JVM_FIELD_PACKAGE_NAME && classNames == JVM_FIELD_CLASS_NAMES -fun Annotations.Annotation.isJvmField(): Boolean = dri.isJvmField() +public fun Annotations.Annotation.isJvmField(): Boolean = dri.isJvmField() diff --git a/core/src/main/kotlin/model/WithChildren.kt b/core/src/main/kotlin/model/WithChildren.kt index 01e69fd0..f73a5aa0 100644 --- a/core/src/main/kotlin/model/WithChildren.kt +++ b/core/src/main/kotlin/model/WithChildren.kt @@ -4,39 +4,39 @@ package org.jetbrains.dokka.model -interface WithChildren { - val children: List +public interface WithChildren { + public val children: List } -inline fun WithChildren<*>.firstChildOfTypeOrNull(): T? = +public inline fun WithChildren<*>.firstChildOfTypeOrNull(): T? = children.filterIsInstance().firstOrNull() -inline fun WithChildren<*>.firstChildOfTypeOrNull(predicate: (T) -> Boolean): T? = +public inline fun WithChildren<*>.firstChildOfTypeOrNull(predicate: (T) -> Boolean): T? = children.filterIsInstance().firstOrNull(predicate) -inline fun WithChildren<*>.firstChildOfType(): T = +public inline fun WithChildren<*>.firstChildOfType(): T = children.filterIsInstance().first() -inline fun WithChildren<*>.childrenOfType(): List = +public inline fun WithChildren<*>.childrenOfType(): List = children.filterIsInstance() -inline fun WithChildren<*>.firstChildOfType(predicate: (T) -> Boolean): T = +public inline fun WithChildren<*>.firstChildOfType(predicate: (T) -> Boolean): T = children.filterIsInstance().first(predicate) -inline fun WithChildren>.firstMemberOfType(): T where T : WithChildren<*> { +public inline fun WithChildren>.firstMemberOfType(): T where T : WithChildren<*> { return withDescendants().filterIsInstance().first() } -inline fun WithChildren>.firstMemberOfType( +public inline fun WithChildren>.firstMemberOfType( predicate: (T) -> Boolean ): T where T : WithChildren<*> = withDescendants().filterIsInstance().first(predicate) -inline fun WithChildren>.firstMemberOfTypeOrNull(): T? where T : WithChildren<*> { +public inline fun WithChildren>.firstMemberOfTypeOrNull(): T? where T : WithChildren<*> { return withDescendants().filterIsInstance().firstOrNull() } -fun T.withDescendants(): Sequence where T : WithChildren { +public fun T.withDescendants(): Sequence where T : WithChildren { return sequence { yield(this@withDescendants) children.forEach { child -> @@ -46,7 +46,7 @@ fun T.withDescendants(): Sequence where T : WithChildren { } @JvmName("withDescendantsProjection") -fun WithChildren<*>.withDescendants(): Sequence { +public fun With