Display `SinceKotlin` everywhere (#2708)

* Introduce `extraOptions`

* Make 'SinceKotlin' option

* Display 'SinceKotlin' everywhere

* Dump API

* Fix CLI bug

* Show custom tags in property brief

* Show custom tags in extension brief

* Show `SinceKotlin` for TypeAlias

* Fix `stdlib.diff`

* Add a test

* Display doc for actual typealias

* Propagate SinceKotlin

* Refactor

* Refactor in `SinceKotlinTransformer`

* Revert "Introduce `extraOptions`"

This reverts commit b83fdf5da31a97e2ae037f46a735d34a2f84d2ec.

* Revert "Make 'SinceKotlin' option"

This reverts commit 69f4641d1776f3a4bcd361919212c2de7fa2364e.

* Introduce `dokka.SinceKotlin` system property instead of extra arg

* Fix API

* Fix tests

* Rename

* Spread on extensions

* Put doc and rename prop

8 files changed, 395 insertions, 67 deletions

diff --git a/integration-tests/gradle/projects/stdlib/stdlib.diff b/integration-tests/gradle/projects/stdlib/stdlib.diff
index dcd5bb70..a2b951ec 100644
--- a/integration-tests/gradle/projects/stdlib/stdlib.diff
+++ b/integration-tests/gradle/projects/stdlib/stdlib.diff
@@ -541,10 +541,11 @@ new file mode 100644
 index 0000000..76356e8
 --- /dev/null
 +++ b/gradle.properties
-@@ -0,0 +1,3 @@
+@@ -0,0 +1,4 @@
 +dokka_build = 611
 +dokka_version = 1.4.20.2-SNAPSHOT
 +org.gradle.jvmargs=-Xmx4096m
++systemProp.dokka.shouldDisplaySinceKotlin=true
 diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
 index d76b502..5028f28 100644
 --- a/gradle/wrapper/gradle-wrapper.properties
diff --git a/plugins/base/api/base.api b/plugins/base/api/base.api
index c299d547..3e74e37b 100644
--- a/plugins/base/api/base.api
+++ b/plugins/base/api/base.api
@@ -1292,6 +1292,13 @@ public final class org/jetbrains/dokka/base/transformers/pages/annotations/Since
 	public fun invoke (Lorg/jetbrains/dokka/model/DModule;Lorg/jetbrains/dokka/plugability/DokkaContext;)Lorg/jetbrains/dokka/model/DModule;
 }
 
+public final class org/jetbrains/dokka/base/transformers/pages/annotations/SinceKotlinVersion : java/lang/Comparable {
+	public fun <init> (Ljava/lang/String;)V
+	public synthetic fun compareTo (Ljava/lang/Object;)I
+	public fun compareTo (Lorg/jetbrains/dokka/base/transformers/pages/annotations/SinceKotlinVersion;)I
+	public fun toString ()Ljava/lang/String;
+}
+
 public abstract interface class org/jetbrains/dokka/base/transformers/pages/comments/CommentsToContentConverter {
 	public abstract fun buildContent (Lorg/jetbrains/dokka/model/doc/DocTag;Lorg/jetbrains/dokka/pages/DCI;Ljava/util/Set;Ljava/util/Set;Lorg/jetbrains/dokka/model/properties/PropertyContainer;)Ljava/util/List;
 }
diff --git a/plugins/base/src/main/kotlin/DokkaBase.kt b/plugins/base/src/main/kotlin/DokkaBase.kt
index 86160b4a..ddc06fe0 100644
--- a/plugins/base/src/main/kotlin/DokkaBase.kt
+++ b/plugins/base/src/main/kotlin/DokkaBase.kt
@@ -36,7 +36,6 @@ import org.jetbrains.dokka.base.translators.descriptors.ExternalClasslikesTransl
 import org.jetbrains.dokka.base.translators.descriptors.ExternalDocumentablesProvider
 import org.jetbrains.dokka.base.utils.NoopIntellijLoggerFactory
 import org.jetbrains.dokka.plugability.DokkaPlugin
-import org.jetbrains.dokka.plugability.configuration
 import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer
 import org.jetbrains.dokka.transformers.pages.PageTransformer
 
@@ -133,7 +132,9 @@ class DokkaBase : DokkaPlugin() {
     }
 
     val sinceKotlinTransformer by extending {
-        CoreExtensions.documentableTransformer providing ::SinceKotlinTransformer
+        CoreExtensions.documentableTransformer providing ::SinceKotlinTransformer applyIf { SinceKotlinTransformer.shouldDisplaySinceKotlin() } order {
+            before(extensionsExtractor)
+        }
     }
 
     val inheritorsExtractor by extending {
@@ -157,7 +158,7 @@ class DokkaBase : DokkaPlugin() {
     }
 
     val sinceKotlinTagContentProvider by extending {
-        customTagContentProvider with SinceKotlinTagContentProvider
+        customTagContentProvider with SinceKotlinTagContentProvider applyIf { SinceKotlinTransformer.shouldDisplaySinceKotlin() }
     }
 
     val pageMerger by extending {
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/ActualTypealiasAdder.kt b/plugins/base/src/main/kotlin/transformers/documentables/ActualTypealiasAdder.kt
index 58c601bc..e895db60 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/ActualTypealiasAdder.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/ActualTypealiasAdder.kt
@@ -67,12 +67,32 @@ class ActualTypealiasAdder : DocumentableTransformer {
             if (element.expectPresentInSet != null) {
                 typealiases[element.dri]?.let { ta ->
                     val merged = element.withNewExtras(element.extra + ActualTypealias(ta.underlyingType)).let {
-                        when(it) {
-                            is DClass -> it.copy(sourceSets = element.sourceSets + ta.sourceSets)
-                            is DEnum ->  it.copy(sourceSets = element.sourceSets + ta.sourceSets)
-                            is DInterface -> it.copy(sourceSets = element.sourceSets + ta.sourceSets)
-                            is DObject -> it.copy(sourceSets = element.sourceSets + ta.sourceSets)
-                            is DAnnotation -> it.copy(sourceSets = element.sourceSets + ta.sourceSets)
+                        when (it) {
+                            is DClass -> it.copy(
+                                documentation = element.documentation + ta.documentation,
+                                sourceSets = element.sourceSets + ta.sourceSets
+                            )
+
+                            is DEnum -> it.copy(
+                                documentation = element.documentation + ta.documentation,
+                                sourceSets = element.sourceSets + ta.sourceSets
+                            )
+
+                            is DInterface -> it.copy(
+                                documentation = element.documentation + ta.documentation,
+                                sourceSets = element.sourceSets + ta.sourceSets
+                            )
+
+                            is DObject -> it.copy(
+                                documentation = element.documentation + ta.documentation,
+                                sourceSets = element.sourceSets + ta.sourceSets
+                            )
+
+                            is DAnnotation -> it.copy(
+                                documentation = element.documentation + ta.documentation,
+                                sourceSets = element.sourceSets + ta.sourceSets
+                            )
+
                             else -> throw IllegalStateException("${it::class.qualifiedName} ${it.name} cannot have copy its sourceSets")
                         }
                     }
diff --git a/plugins/base/src/main/kotlin/transformers/pages/annotations/SinceKotlinTransformer.kt b/plugins/base/src/main/kotlin/transformers/pages/annotations/SinceKotlinTransformer.kt
index f437ebe3..d81cca89 100644
--- a/plugins/base/src/main/kotlin/transformers/pages/annotations/SinceKotlinTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/pages/annotations/SinceKotlinTransformer.kt
@@ -1,93 +1,180 @@
 package org.jetbrains.dokka.base.transformers.pages.annotations
 
+import com.intellij.util.containers.ComparatorUtil.max
 import org.intellij.markdown.MarkdownElementTypes
-import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.DokkaConfiguration
+import org.jetbrains.dokka.Platform
+import org.jetbrains.dokka.base.signatures.KotlinSignatureUtils.annotations
 import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.doc.CustomDocTag
 import org.jetbrains.dokka.model.doc.CustomTagWrapper
+import org.jetbrains.dokka.model.doc.DocumentationNode
 import org.jetbrains.dokka.model.doc.Text
-import org.jetbrains.dokka.model.properties.WithExtraProperties
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.documentation.DocumentableTransformer
+import org.jetbrains.dokka.utilities.associateWithNotNull
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
+class SinceKotlinVersion constructor(str: String) : Comparable<SinceKotlinVersion> {
+    private val parts: List<Int> = str.split(".").map { it.toInt() }
+
+    /**
+     * Corner case: 1.0 == 1.0.0
+     */
+    override fun compareTo(other: SinceKotlinVersion): Int {
+        val i1 = parts.listIterator()
+        val i2 = other.parts.listIterator()
+
+        while (i1.hasNext() || i2.hasNext()) {
+            val diff = (if (i1.hasNext()) i1.next() else 0) - (if (i2.hasNext()) i2.next() else 0)
+            if (diff != 0) return diff
+        }
+
+        return 0
+    }
+
+    override fun toString(): String = parts.joinToString(".")
+}
+
 class SinceKotlinTransformer(val context: DokkaContext) : DocumentableTransformer {
 
+    private val minSinceKotlinVersionOfPlatform = mapOf(
+        Platform.common to SinceKotlinVersion("1.2"),
+        Platform.jvm to SinceKotlinVersion("1.0"),
+        Platform.js to SinceKotlinVersion("1.1"),
+        Platform.native to SinceKotlinVersion("1.3")
+    )
+
     override fun invoke(original: DModule, context: DokkaContext) = original.transform() as DModule
 
-    private fun <T : Documentable> T.transform(): Documentable =
-        when (this) {
+    private fun <T : Documentable> T.transform(parent: SourceSetDependent<SinceKotlinVersion>? = null): Documentable {
+        val versions = calculateVersions(parent)
+        return when (this) {
             is DModule -> copy(
                 packages = packages.map { it.transform() as DPackage }
             )
+
             is DPackage -> copy(
                 classlikes = classlikes.map { it.transform() as DClasslike },
                 functions = functions.map { it.transform() as DFunction },
-                properties = properties.map { it.transform() as DProperty }
+                properties = properties.map { it.transform() as DProperty },
+                typealiases = typealiases.map { it.transform() as DTypeAlias }
             )
+
             is DClass -> copy(
-                documentation = appendSinceKotlin(),
-                classlikes = classlikes.map { it.transform() as DClasslike },
-                functions = functions.map { it.transform() as DFunction },
-                properties = properties.map { it.transform() as DProperty }
+                documentation = appendSinceKotlin(versions),
+                classlikes = classlikes.map { it.transform(versions) as DClasslike },
+                functions = functions.map { it.transform(versions) as DFunction },
+                properties = properties.map { it.transform(versions) as DProperty }
             )
+
             is DEnum -> copy(
-                documentation = appendSinceKotlin(),
-                classlikes = classlikes.map { it.transform() as DClasslike },
-                functions = functions.map { it.transform() as DFunction },
-                properties = properties.map { it.transform() as DProperty }
+                documentation = appendSinceKotlin(versions),
+                classlikes = classlikes.map { it.transform(versions) as DClasslike },
+                functions = functions.map { it.transform(versions) as DFunction },
+                properties = properties.map { it.transform(versions) as DProperty }
             )
+
             is DInterface -> copy(
-                documentation = appendSinceKotlin(),
-                classlikes = classlikes.map { it.transform() as DClasslike },
-                functions = functions.map { it.transform() as DFunction },
-                properties = properties.map { it.transform() as DProperty }
+                documentation = appendSinceKotlin(versions),
+                classlikes = classlikes.map { it.transform(versions) as DClasslike },
+                functions = functions.map { it.transform(versions) as DFunction },
+                properties = properties.map { it.transform(versions) as DProperty }
             )
+
             is DObject -> copy(
-                documentation = appendSinceKotlin(),
-                classlikes = classlikes.map { it.transform() as DClasslike },
-                functions = functions.map { it.transform() as DFunction },
-                properties = properties.map { it.transform() as DProperty }
+                documentation = appendSinceKotlin(versions),
+                classlikes = classlikes.map { it.transform(versions) as DClasslike },
+                functions = functions.map { it.transform(versions) as DFunction },
+                properties = properties.map { it.transform(versions) as DProperty }
             )
+
+            is DTypeAlias -> copy(
+                documentation = appendSinceKotlin(versions)
+            )
+
             is DAnnotation -> copy(
-                documentation = appendSinceKotlin(),
-                classlikes = classlikes.map { it.transform() as DClasslike },
-                functions = functions.map { it.transform() as DFunction },
-                properties = properties.map { it.transform() as DProperty }
+                documentation = appendSinceKotlin(versions),
+                classlikes = classlikes.map { it.transform(versions) as DClasslike },
+                functions = functions.map { it.transform(versions) as DFunction },
+                properties = properties.map { it.transform(versions) as DProperty }
             )
+
             is DFunction -> copy(
-                documentation = appendSinceKotlin()
+                documentation = appendSinceKotlin(versions)
             )
+
             is DProperty -> copy(
-                documentation = appendSinceKotlin()
+                documentation = appendSinceKotlin(versions)
             )
+
             is DParameter -> copy(
-                documentation = appendSinceKotlin()
+                documentation = appendSinceKotlin(versions)
             )
+
             else -> this.also { context.logger.warn("Unrecognized documentable $this while SinceKotlin transformation") }
         }
+    }
+
+    private fun List<Annotations.Annotation>.findSinceKotlinAnnotation(): Annotations.Annotation? =
+        this.find { it.dri.packageName == "kotlin" && it.dri.classNames == "SinceKotlin" }
+
+    private fun Documentable.getVersion(sourceSet: DokkaConfiguration.DokkaSourceSet): SinceKotlinVersion {
+        val annotatedVersion =
+            annotations()[sourceSet]
+                ?.findSinceKotlinAnnotation()
+                ?.params?.get("version").safeAs<StringValue>()?.value
+                ?.let { SinceKotlinVersion(it) }
 
-    private fun Documentable.appendSinceKotlin() =
+        val minSinceKotlin = minSinceKotlinVersionOfPlatform[sourceSet.analysisPlatform]
+            ?: throw IllegalStateException("No value for platform: ${sourceSet.analysisPlatform}")
+
+        return annotatedVersion?.takeIf { version -> version >= minSinceKotlin } ?: minSinceKotlin
+    }
+
+
+    private fun Documentable.calculateVersions(parent: SourceSetDependent<SinceKotlinVersion>?): SourceSetDependent<SinceKotlinVersion> {
+        return sourceSets.associateWithNotNull { sourceSet ->
+            val version = getVersion(sourceSet)
+            val parentVersion = parent?.get(sourceSet)
+            if (parentVersion != null)
+                max(version, parentVersion)
+            else
+                version
+        }
+    }
+
+    private fun Documentable.appendSinceKotlin(versions: SourceSetDependent<SinceKotlinVersion>) =
         sourceSets.fold(documentation) { acc, sourceSet ->
-            safeAs<WithExtraProperties<Documentable>>()?.extra?.get(Annotations)?.directAnnotations?.get(sourceSet)?.find {
-                it.dri == DRI("kotlin", "SinceKotlin")
-            }?.params?.get("version").safeAs<StringValue>()?.value?.let { version ->
+
+            val version = versions[sourceSet]
+
+            val sinceKotlinCustomTag = CustomTagWrapper(
+                CustomDocTag(
+                    listOf(
+                        Text(
+                            version.toString()
+                        )
+                    ),
+                    name = MarkdownElementTypes.MARKDOWN_FILE.name
+                ),
+                "Since Kotlin"
+            )
+            if (acc[sourceSet] == null)
+                acc + (sourceSet to DocumentationNode(listOf(sinceKotlinCustomTag)))
+            else
                 acc.mapValues {
                     if (it.key == sourceSet) it.value.copy(
                         it.value.children + listOf(
-                            CustomTagWrapper(
-                                CustomDocTag(
-                                    listOf(
-                                        Text(version.dropWhile { it == '"' }.dropLastWhile { it == '"' }
-                                        )
-                                    ),
-                                    name = MarkdownElementTypes.MARKDOWN_FILE.name
-                                ),
-                                "Since Kotlin"
-                            )
+                            sinceKotlinCustomTag
                         )
                     ) else it.value
                 }
-            } ?: acc
         }
+
+    internal companion object {
+        internal const val SHOULD_DISPLAY_SINCE_KOTLIN_SYS_PROP = "dokka.shouldDisplaySinceKotlin"
+        internal fun shouldDisplaySinceKotlin() =
+            System.getProperty(SHOULD_DISPLAY_SINCE_KOTLIN_SYS_PROP) in listOf("true", "1")
+    }
 }
diff --git a/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt b/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt
index ff60170c..9d45f7a3 100644
--- a/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt
+++ b/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt
@@ -802,6 +802,7 @@ open class DefaultPageCreator(
                 props.forEach {
                     +buildSignature(it)
                     contentForBrief(it)
+                    contentForCustomTagsBrief(it)
                 }
             }
         }
diff --git a/plugins/base/src/test/kotlin/content/annotations/SinceKotlinTest.kt b/plugins/base/src/test/kotlin/content/annotations/SinceKotlinTest.kt
index 84f5b647..d4a17869 100644
--- a/plugins/base/src/test/kotlin/content/annotations/SinceKotlinTest.kt
+++ b/plugins/base/src/test/kotlin/content/annotations/SinceKotlinTest.kt
@@ -1,15 +1,26 @@
 package content.annotations
 
 import matchers.content.*
-import org.jetbrains.dokka.base.testApi.testRunner.BaseAbstractTest
+import org.jetbrains.dokka.Platform
+import org.jetbrains.dokka.base.transformers.pages.annotations.SinceKotlinTransformer
+import org.jetbrains.dokka.base.transformers.pages.annotations.SinceKotlinVersion
+import org.jetbrains.dokka.model.DFunction
+import org.jetbrains.dokka.model.dfs
+import org.jetbrains.dokka.model.doc.CustomTagWrapper
+import org.jetbrains.dokka.model.doc.Text
 import org.jetbrains.dokka.pages.ContentPage
-import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.*
+import signatures.AbstractRenderingTest
 import utils.ParamAttributes
+import utils.TestOutputWriterPlugin
+import utils.assertNotNull
 import utils.bareSignature
+import kotlin.test.assertEquals
 
-class SinceKotlinTest : BaseAbstractTest() {
 
-    private val testConfiguration = dokkaConfiguration {
+class SinceKotlinTest : AbstractRenderingTest() {
+
+    val testConfiguration = dokkaConfiguration {
         sourceSets {
             sourceSet {
                 sourceRoots = listOf("src/")
@@ -18,8 +29,208 @@ class SinceKotlinTest : BaseAbstractTest() {
         }
     }
 
+    @BeforeEach
+    fun setSystemProperty() {
+        System.setProperty(SinceKotlinTransformer.SHOULD_DISPLAY_SINCE_KOTLIN_SYS_PROP, "true")
+    }
+    @AfterEach
+    fun clearSystemProperty() {
+        System.clearProperty(SinceKotlinTransformer.SHOULD_DISPLAY_SINCE_KOTLIN_SYS_PROP)
+    }
+
+    @Test
+    fun versionsComparing() {
+        assert(SinceKotlinVersion("1.0").compareTo(SinceKotlinVersion("1.0")) == 0)
+        assert(SinceKotlinVersion("1.0.0").compareTo(SinceKotlinVersion("1")) == 0)
+        assert(SinceKotlinVersion("1.0") >= SinceKotlinVersion("1.0"))
+        assert(SinceKotlinVersion("1.1") > SinceKotlinVersion("1"))
+        assert(SinceKotlinVersion("1.0") < SinceKotlinVersion("2.0"))
+        assert(SinceKotlinVersion("1.0") < SinceKotlinVersion("2.2"))
+    }
+
+    @Test
+    fun `rendered SinceKotlin custom tag for typealias, extensions, functions, properties`() {
+        val writerPlugin = TestOutputWriterPlugin()
+
+        testInline(
+            """
+            |/src/main/kotlin/test/source.kt
+            |package test
+            |
+            |@SinceKotlin("1.5")
+            |fun ring(abc: String): String {
+            |    return "My precious " + abc
+            |}
+            |@SinceKotlin("1.5")
+            |fun String.extension(abc: String): String {
+            |    return "My precious " + abc
+            |}            
+            |@SinceKotlin("1.5")
+            |typealias Str = String
+            |@SinceKotlin("1.5")
+            |val str = "str"
+        """.trimIndent(),
+            testConfiguration,
+            pluginOverrides = listOf(writerPlugin)
+        ) {
+            renderingStage = { _, _ ->
+                val content = writerPlugin.renderedContent("root/test/index.html")
+                assert(content.getElementsContainingOwnText("Since Kotlin").count() == 4)
+            }
+        }
+    }
+
+    @Test
+    fun `should propagate SinceKotlin`() {
+        testInline(
+            """
+            |/src/main/kotlin/test/source.kt
+            |package test
+            |
+            |@SinceKotlin("1.5")
+            |class A {
+            |   fun ring(abc: String): String {
+            |       return "My precious " + abc
+            |   }
+            |}
+        """.trimIndent(), testConfiguration
+        ) {
+            documentablesTransformationStage = { module ->
+                @Suppress("UNCHECKED_CAST") val funcs = module.children.single { it.name == "test" }
+                    .children.single { it.name == "A" }
+                    .children.filter { it.name == "ring" && it is DFunction } as List<DFunction>
+                with(funcs) {
+                    val sinceKotlin = mapOf(
+                        Platform.jvm to SinceKotlinVersion("1.5"),
+                    )
+
+                    for(i in sinceKotlin) {
+                        val tag =
+                            find { it.sourceSets.first().analysisPlatform == i.key }?.documentation?.values?.first()
+                                ?.dfs { it is CustomTagWrapper && it.name == "Since Kotlin" }
+                                .assertNotNull("SinceKotlin[${i.key}]")
+                        assertEquals((tag.children.first() as Text).body, i.value.toString())
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `mpp fun without SinceKotlin annotation`() {
+        val configuration =   dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    sourceRoots = listOf("src/")
+                    analysisPlatform = "jvm"
+                }
+                sourceSet {
+                    sourceRoots = listOf("src/")
+                    analysisPlatform = "native"
+                }
+                sourceSet {
+                    sourceRoots = listOf("src/")
+                    analysisPlatform = "common"
+                }
+                sourceSet {
+                    sourceRoots = listOf("src/")
+                    analysisPlatform = "js"
+                }
+            }
+        }
+        testInline(
+            """
+            |/src/main/kotlin/test/source.kt
+            |package test
+            |
+            |fun ring(abc: String): String {
+            |    return "My precious " + abc
+            |}
+        """.trimIndent(), configuration
+        ) {
+            documentablesTransformationStage = { module ->
+                @Suppress("UNCHECKED_CAST") val funcs = module.children.single { it.name == "test" }
+                    .children.filter { it.name == "ring" && it is DFunction } as List<DFunction>
+                with(funcs) {
+                    val sinceKotlin = mapOf(
+                        Platform.common to SinceKotlinVersion("1.2"),
+                        Platform.jvm to SinceKotlinVersion("1.0"),
+                        Platform.js to SinceKotlinVersion("1.1"),
+                        Platform.native to SinceKotlinVersion("1.3")
+                    )
+
+                    for(i in sinceKotlin) {
+                        val tag =
+                            find { it.sourceSets.first().analysisPlatform == i.key }?.documentation?.values?.first()
+                                ?.dfs { it is CustomTagWrapper && it.name == "Since Kotlin" }
+                                .assertNotNull("SinceKotlin[${i.key}]")
+                        assertEquals((tag.children.first() as Text).body, i.value.toString())
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `mpp fun with SinceKotlin annotation`() {
+        val configuration =   dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    sourceRoots = listOf("src/")
+                    analysisPlatform = "jvm"
+                }
+                sourceSet {
+                    sourceRoots = listOf("src/")
+                    analysisPlatform = "native"
+                }
+                sourceSet {
+                    sourceRoots = listOf("src/")
+                    analysisPlatform = "common"
+                }
+                sourceSet {
+                    sourceRoots = listOf("src/")
+                    analysisPlatform = "js"
+                }
+            }
+        }
+        testInline(
+            """
+            |/src/main/kotlin/test/source.kt
+            |package test
+            |
+            |/** dssdd */
+            |@SinceKotlin("1.3")
+            |fun ring(abc: String): String {
+            |    return "My precious " + abc
+            |}
+        """.trimIndent(), configuration
+        ) {
+            documentablesTransformationStage = { module ->
+                @Suppress("UNCHECKED_CAST") val funcs = module.children.single { it.name == "test" }
+                    .children.filter { it.name == "ring" && it is DFunction } as List<DFunction>
+                with(funcs) {
+                    val sinceKotlin = mapOf(
+                        Platform.common to SinceKotlinVersion("1.3"),
+                        Platform.jvm to SinceKotlinVersion("1.3"),
+                        Platform.js to SinceKotlinVersion("1.3"),
+                        Platform.native to SinceKotlinVersion("1.3")
+                    )
+
+                    for(i in sinceKotlin) {
+                        val tag =
+                            find { it.sourceSets.first().analysisPlatform == i.key }?.documentation?.values?.first()
+                                ?.dfs { it is CustomTagWrapper && it.name == "Since Kotlin" }
+                                .assertNotNull("SinceKotlin[${i.key}]")
+                        assertEquals((tag.children.first() as Text).body, i.value.toString())
+                    }
+                }
+            }
+        }
+    }
+
     @Test
-    fun `function with since kotlin annotation`() {
+    fun `should do not render since kotlin tag when flag is unset`() {
+        clearSystemProperty()
         testInline(
             """
             |/src/main/kotlin/test/source.kt
diff --git a/runners/cli/src/main/kotlin/org/jetbrains/dokka/main.kt b/runners/cli/src/main/kotlin/org/jetbrains/dokka/main.kt
index aca57f7e..7fe782a9 100644
--- a/runners/cli/src/main/kotlin/org/jetbrains/dokka/main.kt
+++ b/runners/cli/src/main/kotlin/org/jetbrains/dokka/main.kt
@@ -408,18 +408,18 @@ fun parseLinks(links: List<String>): List<ExternalDocumentationLink> {
 }
 
 fun initializeConfiguration(globalArguments: GlobalArguments): DokkaConfiguration = if (globalArguments.json != null) {
-        val jsonContent = Paths.get(checkNotNull(globalArguments.json)).toFile().readText()
-        val globals = GlobalDokkaConfiguration(jsonContent)
-        val dokkaConfigurationImpl = DokkaConfigurationImpl(jsonContent)
+    val jsonContent = Paths.get(checkNotNull(globalArguments.json)).toFile().readText()
+    val globals = GlobalDokkaConfiguration(jsonContent)
+    val dokkaConfigurationImpl = DokkaConfigurationImpl(jsonContent)
 
-        dokkaConfigurationImpl.apply(globals).apply {
-            sourceSets.forEach {
-                it.externalDocumentationLinks.cast<MutableSet<ExternalDocumentationLink>>().addAll(defaultLinks(it))
-            }
+    dokkaConfigurationImpl.apply(globals).apply {
+        sourceSets.forEach {
+            it.externalDocumentationLinks.cast<MutableSet<ExternalDocumentationLink>>().addAll(defaultLinks(it))
         }
-    } else {
-        globalArguments
     }
+} else {
+    globalArguments
+}
 
 fun main(args: Array<String>) {
     val globalArguments = GlobalArguments(args)