Modularization of the project

build.gradle.kts

@@ -1,12 +1,25 @@
-import org.gradle.jvm.tasks.Jar
-import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-import org.jetbrains.dokka.gradle.DokkaTask
+/*
+ * Lincheck
+ *
+ * Copyright (C) 2019 - 2025 JetBrains s.r.o.
+ *
+ * This Source Code Form is subject to the terms of the
+ * Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed
+ * with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
 import okhttp3.MultipartBody
 import okhttp3.OkHttpClient
 import okhttp3.Request
 import okhttp3.RequestBody.Companion.asRequestBody
-import java.util.*
+import org.gradle.kotlin.dsl.invoke
+import org.gradle.kotlin.dsl.java
+import org.gradle.kotlin.dsl.kotlin
+import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import java.nio.file.Paths
+import java.util.Base64
+
 
 buildscript {
     repositories {
@@ -40,6 +53,33 @@ java {
     configureJava()
 }
 
+subprojects {
+    plugins.apply("java")
+    plugins.apply("org.jetbrains.kotlin.jvm")
+
+    kotlin {
+        configureKotlin()
+    }
+
+    java {
+        configureJava()
+    }
+}
+
+/*
+ * Unfortunately, Lincheck was affected by the following bug in atomicfu
+ * (at the latest version 0.27.0 at the time when this comment was written):
+ * https://github.com/Kotlin/kotlinx-atomicfu/issues/525.
+ *
+ * To bypass the bug, the solution is to disable post-compilation JVM bytecode transformation
+ * and enable only the JVM-IR transformation at the Kotlin compilation stage.
+ *
+ * See also https://github.com/JetBrains/lincheck/issues/668 for a more detailed description of the bug.
+ */
+atomicfu {
+    transformJvm = false
+}
+
 sourceSets {
     main {
         java.srcDirs("src/jvm/main")
@@ -96,7 +136,10 @@ sourceSets {
         val atomicfuVersion: String by project
 
         compileOnly(project(":bootstrap"))
-        api(project(":trace"))
+        api(project(":common")) // TODO: `api` is used here in order to allow users of `lincheck` to access `LoggingLevel` enum class stored there,
+                                //  but later this enum will be marked as deprecated and then hidden, after that `api` should be changed to `implementation`
+        implementation(project(":jvm-agent"))
+        implementation(project(":trace"))
 
         api("org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion")
         api("org.jetbrains.kotlin:kotlin-stdlib-common:$kotlinVersion")
@@ -178,6 +221,10 @@ tasks {
     named<KotlinCompile>("compileTraceRecorderIntegrationTestKotlin") {
         setupKotlinToolchain(project)
     }
+
+    withType<KotlinCompile> {
+        getAccessToInternalDefinitionsOf(project(":common"))
+    }
 }
 
 // add an association to main and test modules to enable access to `internal` APIs inside integration tests:
@@ -201,19 +248,6 @@ fun KotlinCompilation<*>.configureAssociation() {
     associateWith(test)
 }
 
-/*
- * Unfortunately, Lincheck was affected by the following bug in atomicfu
- * (at the latest version 0.27.0 at the time when this comment was written):
- * https://github.com/Kotlin/kotlinx-atomicfu/issues/525.
- *
- * To bypass the bug, the solution is to disable post-compilation JVM bytecode transformation
- * and enable only the JVM-IR transformation at the Kotlin compilation stage.
- *
- * See also https://github.com/JetBrains/lincheck/issues/668 for a more detailed description of the bug.
- */
-atomicfu {
-    transformJvm = false
-}
 
 tasks.withType<Test> {
     javaLauncher.set(
@@ -281,10 +315,10 @@ tasks {
         if (!ideaActive) {
             // We need to be able to run these tests in IntelliJ IDEA.
             // Unfortunately, the current Gradle support doesn't detect
-            // the `jvmTestIsolated` and `trace[Debugger/Recorder]IntegrationTest` tasks.
+            // the `testIsolated` and `trace[Debugger/Recorder]IntegrationTest` tasks.
             exclude("**/*IsolatedTest*")
-            exclude("org/jetbrains/trace_debugger/integration/*")
-            exclude("org/jetbrains/trace_recorder/integration/*")
+            exclude("org/jetbrains/trace/debugger/integration/*")
+            exclude("org/jetbrains/trace/recorder/integration/*")
         }
         // Do not run JdkUnsafeTraceRepresentationTest on Java 12 or earlier,
         // as this test relies on specific ConcurrentHashMap implementation.
@@ -340,41 +374,42 @@ tasks {
 
     registerTraceAgentIntegrationTestsPrerequisites()
 
+    val copyTraceDebuggerFatJar = copyTraceAgentFatJar(project(":trace-debugger"), "trace-debugger-fat.jar")
+    val copyTraceRecorderFatJar = copyTraceAgentFatJar(project(":trace-recorder"), "trace-recorder-fat.jar")
+
     val traceDebuggerIntegrationTest = register<Test>("traceDebuggerIntegrationTest") {
         configureJvmTestCommon()
         group = "verification"
-        include("org/jetbrains/trace_debugger/integration/*")
+        include("org/jetbrains/trace/debugger/integration/*")
 
         testClassesDirs = sourceSets["traceDebuggerIntegrationTest"].output.classesDirs
         classpath = sourceSets["traceDebuggerIntegrationTest"].runtimeClasspath
 
         outputs.upToDateWhen { false } // Always run tests when called
-        dependsOn(traceAgentIntegrationTestsPrerequisites)
+        dependsOn(copyTraceDebuggerFatJar)
     }
 
     val traceRecorderIntegrationTest = register<Test>("traceRecorderIntegrationTest") {
         configureJvmTestCommon()
         group = "verification"
-        include("org/jetbrains/trace_recorder/integration/*")
+        include("org/jetbrains/trace/recorder/integration/*")
 
         testClassesDirs = sourceSets["traceRecorderIntegrationTest"].output.classesDirs
         classpath = sourceSets["traceRecorderIntegrationTest"].runtimeClasspath
 
         outputs.upToDateWhen { false } // Always run tests when called
-        dependsOn(traceAgentIntegrationTestsPrerequisites)
+        dependsOn(copyTraceRecorderFatJar)
     }
 
     check {
         dependsOn += testIsolated
     }
 }
 
-registerTraceAgentTasks()
-
 val bootstrapJar = tasks.register<Copy>("bootstrapJar") {
     dependsOn(":bootstrap:jar")
     from(file("${project(":bootstrap").layout.buildDirectory.get()}/libs/bootstrap.jar"))
-    into(file("${layout.buildDirectory.get()}/resources/main"))
+    into(file("${project(":jvm-agent").layout.buildDirectory.get()}/resources/main"))
 }
 
 val jar = tasks.named<Jar>("jar") {
@@ -389,10 +424,10 @@ val sourcesJar = tasks.register<Jar>("sourcesJar") {
     archiveClassifier.set("sources")
 }
 
-val javadocJar = createJavadocJar()
+val javadocJar = createJavadocJar("src/jvm/main")
 
 tasks.withType<Jar> {
-    dependsOn(bootstrapJar)
+    dependsOn(":bootstrapJar")
 
     manifest {
         val inceptionYear: String by project
@@ -410,7 +445,7 @@ tasks.withType<Jar> {
 }
 
 tasks.named("processResources").configure {
-    dependsOn(bootstrapJar)
+    dependsOn(":bootstrapJar")
 }
 
 publishing {
@@ -458,6 +493,8 @@ tasks {
     val packSonatypeCentralBundle by registering(Zip::class) {
         group = "publishing"
 
+        dependsOn(":common:publishMavenPublicationToArtifactsRepository")
+        dependsOn(":jvm-agent:publishMavenPublicationToArtifactsRepository")
         dependsOn(":trace:publishMavenPublicationToArtifactsRepository")
         dependsOn(":publishMavenPublicationToArtifactsRepository")
 

buildSrc/src/main/kotlin/Documentation.kt

@@ -10,16 +10,16 @@
 
 import org.gradle.api.Project
 import org.gradle.api.tasks.TaskProvider
-import org.gradle.jvm.tasks.Jar
+import org.gradle.api.tasks.bundling.Jar
 import org.jetbrains.dokka.gradle.DokkaTask
 import org.gradle.kotlin.dsl.*
 
-fun Project.createJavadocJar(): TaskProvider<Jar> {
+fun Project.createJavadocJar(mainSourceSetPath: String = "src/main"): TaskProvider<Jar> {
     val dokkaHtml = tasks.named<DokkaTask>("dokkaHtml") {
         outputDirectory.set(file("${layout.buildDirectory.get()}/javadoc"))
         dokkaSourceSets {
             named("main") {
-                sourceRoots.from(file("src/jvm/main"))
+                sourceRoots.from(file(mainSourceSetPath))
                 reportUndocumented.set(false)
             }
         }

buildSrc/src/main/kotlin/Toolchain.kt

@@ -16,6 +16,8 @@ import org.gradle.jvm.toolchain.JavaToolchainService
 import org.gradle.kotlin.dsl.provideDelegate
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import java.nio.file.Paths
+import kotlin.text.get
 
 fun KotlinJvmProjectExtension.configureKotlin() {
     compilerOptions {
@@ -51,4 +53,17 @@ private fun KotlinCompile.setupKotlinToolchain(javaToolchains: JavaToolchainServ
     kotlinJavaToolchain.toolchain.use(javaToolchains.launcherFor {
         languageVersion.set(JavaLanguageVersion.of(jdkToolchainVersion))
     })
+}
+
+fun KotlinCompile.getAccessToInternalDefinitionsOf(vararg projects: Project) {
+    projects.forEach { project ->
+        val mainSourceSet = project.extensions
+            .getByType(JavaPluginExtension::class.java).sourceSets
+            .getByName("main").output.classesDirs
+        val jarArchive = Paths.get(project.layout.buildDirectory.get().asFile.absolutePath, "libs",
+            if (project.name == "lincheck") project.name + "-" + project.version + ".jar"
+            else project.name + ".jar"
+        ).toFile()
+        friendPaths.from(mainSourceSet + jarArchive)
+    }
 }

buildSrc/src/main/kotlin/TraceAgentIntegrationTestsTasks.kt

@@ -63,6 +63,26 @@ fun Project.registerTraceAgentIntegrationTestsPrerequisites() {
 
     traceAgentIntegrationTestsPrerequisites = tasks.register("traceAgentIntegrationTestsPrerequisites") {
         prerequisite.forEach { dependsOn(it) }
-        dependsOn("traceAgentFatJar")
+        dependsOn(":trace-debugger:traceDebuggerFatJar")
+        dependsOn(":trace-recorder:traceRecorderFatJar")
     }
+}
+
+/**
+ * This function is required to copy `trace-recorder-fat.jar` and `trace-debugger-fat.jar` files from
+ * the corresponding projects into the lincheck's build directory. This allows integration tests to see
+ * the fat-jars and add paths to them via `-javaagent` VM flag.
+ *
+ * @param fromProject trace-debugger/recorder project from which to copy the fat-jar.
+ * @param fatJarName expected fat-jar name.
+ */
+fun Project.copyTraceAgentFatJar(fromProject: Project, fatJarName: String): TaskProvider<Copy> {
+    val copyTraceAgentFatJar = tasks.register<Copy>("${fromProject.name}_copyAgentFatJar") {
+        dependsOn(traceAgentIntegrationTestsPrerequisites)
+        val fatJarFile = fromProject.layout.buildDirectory.file("libs/$fatJarName")
+        from(fatJarFile)
+        into(layout.buildDirectory.dir("libs"))
+    }
+
+    return copyTraceAgentFatJar
 }

buildSrc/src/main/kotlin/TraceAgentTasks.kt

@@ -19,7 +19,7 @@ import org.gradle.api.plugins.JavaPluginExtension
 
 // Below are tasks that are used by the trace debugger plugin.
 // When these jars are loaded the `-Dlincheck.traceDebuggerMode=true` or `-Dlincheck.traceRecorderMode=true` VM argument is expected
-fun Project.registerTraceAgentTasks() {
+fun Project.registerTraceAgentTasks(fatJarName: String, fatJarTaskName: String, premainClass: String) {
     // Ensure the Java plugin is applied (for sourceSets and runtimeClasspath)
     plugins.apply("java")
 
@@ -28,12 +28,12 @@ fun Project.registerTraceAgentTasks() {
 
     val runtimeClasspath = configurations.getByName("runtimeClasspath")
 
-    val traceAgentFatJar = tasks.register<Jar>("traceAgentFatJar") {
-        archiveBaseName.set("lincheck-fat")
+    val traceAgentFatJar = tasks.register<Jar>(fatJarTaskName) {
+        archiveBaseName.set(fatJarName)
         archiveVersion.set("")
         duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 
-        dependsOn("bootstrapJar")
+        dependsOn(":bootstrapJar")
 
         // Include compiled sources
         from(mainSourceSet.output)
@@ -48,7 +48,7 @@ fun Project.registerTraceAgentTasks() {
         manifest {
             attributes(
                 mapOf(
-                    "Premain-Class" to "org.jetbrains.kotlinx.lincheck.traceagent.TraceAgent",
+                    "Premain-Class" to premainClass,
                     "Can-Redefine-Classes" to "true",
                     "Can-Retransform-Classes" to "true"
                 )
@@ -57,8 +57,8 @@ fun Project.registerTraceAgentTasks() {
     }
 
     // This jar is useful to add as a dependency to a test project to be able to debug
-    val traceAgentJarNoDeps = tasks.register<Jar>("traceAgentJarNoDeps") {
-        archiveBaseName.set("nodeps-trace-debugger")
+    val traceAgentJarNoDeps = tasks.register<Jar>("${fatJarTaskName}NoDeps") {
+        archiveBaseName.set("nodeps-$fatJarName")
         duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 
         from(mainSourceSet.output)