Update kotlin version to 2.1.0 (#230)

* Upgrade kotlin version

* Fix tailrec warning in usvm-util module

* Remove context receivers from the project

* Remove the context receivers compiler option

* Test fixes

buildSrc/build.gradle.kts

@@ -2,7 +2,7 @@ plugins {
     `kotlin-dsl`
 }
 
-val kotlinVersion = "1.9.20"
+val kotlinVersion = "2.1.0"
 val detektVersion = "1.23.5"
 val gjavahVersion = "0.3.1"
 

buildSrc/src/main/kotlin/Dependencies.kt

@@ -5,14 +5,14 @@ import org.gradle.plugin.use.PluginDependenciesSpec
 object Versions {
     const val detekt = "1.18.1"
     const val ini4j = "0.5.4"
-    const val jacodb = "81ccf5aaed"
+    const val jacodb = "6539d5020c"
     const val juliet = "1.3.2"
     const val junit = "5.9.3"
-    const val kotlin = "1.9.20"
-    const val kotlin_logging = "1.8.3"
-    const val kotlinx_collections = "0.3.5"
-    const val kotlinx_coroutines = "1.6.4"
-    const val kotlinx_serialization = "1.4.1"
+    const val kotlin = "2.1.0"
+    const val kotlin_logging = "3.0.5"
+    const val kotlinx_collections = "0.3.8"
+    const val kotlinx_coroutines = "1.10.0"
+    const val kotlinx_serialization = "1.7.3"
     const val ksmt = "0.5.26"
     const val logback = "1.4.8"
     const val mockk = "1.13.4"

buildSrc/src/main/kotlin/usvm.kotlin-conventions.gradle.kts

@@ -38,7 +38,6 @@ tasks {
     withType<KotlinCompile> {
         kotlinOptions {
             jvmTarget = JavaVersion.VERSION_1_8.toString()
-            freeCompilerArgs += "-Xallow-result-return-type"
             freeCompilerArgs += "-Xsam-conversions=class"
             allWarningsAsErrors = true
         }

usvm-dataflow/build.gradle.kts

@@ -1,5 +1,3 @@
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-
 plugins {
     id("usvm.kotlin-conventions")
 }
@@ -10,12 +8,6 @@ dependencies {
     implementation(Libs.sarif4k)
 }
 
-tasks.withType<KotlinCompile> {
-    kotlinOptions {
-        freeCompilerArgs += "-Xcontext-receivers"
-    }
-}
-
 publishing {
     publications {
         create<MavenPublication>("maven") {

usvm-dataflow/src/main/kotlin/org/usvm/dataflow/config/Condition.kt

@@ -41,9 +41,9 @@ import org.usvm.dataflow.taint.Tainted
 import org.usvm.dataflow.util.Traits
 import org.usvm.dataflow.util.removeTrailingElementAccessors
 
-context(Traits<CommonMethod, CommonInst>)
 open class BasicConditionEvaluator(
-    internal val positionResolver: PositionResolver<Maybe<CommonValue>>,
+    val traits: Traits<CommonMethod, CommonInst>,
+    internal val positionResolver: PositionResolver<Maybe<CommonValue>>
 ) : ConditionVisitor<Boolean> {
 
     override fun visit(condition: ConstantTrue): Boolean {
@@ -74,35 +74,35 @@ open class BasicConditionEvaluator(
         error("Unexpected condition: $condition")
     }
 
-    override fun visit(condition: IsConstant): Boolean {
+    override fun visit(condition: IsConstant): Boolean = with(traits) {
         positionResolver.resolve(condition.position).onSome {
             return isConstant(it)
         }
         return false
     }
 
-    override fun visit(condition: ConstantEq): Boolean {
+    override fun visit(condition: ConstantEq): Boolean = with(traits) {
         positionResolver.resolve(condition.position).onSome { value ->
             return eqConstant(value, condition.value)
         }
         return false
     }
 
-    override fun visit(condition: ConstantLt): Boolean {
+    override fun visit(condition: ConstantLt): Boolean = with(traits) {
         positionResolver.resolve(condition.position).onSome { value ->
             return ltConstant(value, condition.value)
         }
         return false
     }
 
-    override fun visit(condition: ConstantGt): Boolean {
+    override fun visit(condition: ConstantGt): Boolean = with(traits) {
         positionResolver.resolve(condition.position).onSome { value ->
             return gtConstant(value, condition.value)
         }
         return false
     }
 
-    override fun visit(condition: ConstantMatches): Boolean {
+    override fun visit(condition: ConstantMatches): Boolean = with(traits) {
         positionResolver.resolve(condition.position).onSome { value ->
             return matches(value, condition.pattern)
         }
@@ -117,21 +117,21 @@ open class BasicConditionEvaluator(
         error("This visitor does not support condition $condition. Use FactAwareConditionEvaluator instead")
     }
 
-    override fun visit(condition: TypeMatches): Boolean {
+    override fun visit(condition: TypeMatches): Boolean = with(traits) {
         positionResolver.resolve(condition.position).onSome { value ->
             return typeMatches(value, condition)
         }
         return false
     }
 }
 
-context(Traits<CommonMethod, CommonInst>)
 class FactAwareConditionEvaluator(
+    traits: Traits<CommonMethod, CommonInst>,
     private val fact: Tainted,
     positionResolver: PositionResolver<Maybe<CommonValue>>,
-) : BasicConditionEvaluator(positionResolver) {
+) : BasicConditionEvaluator(traits, positionResolver) {
 
-    override fun visit(condition: ContainsMark): Boolean {
+    override fun visit(condition: ContainsMark): Boolean = with(traits) {
         if (fact.mark != condition.mark) return false
         positionResolver.resolve(condition.position).onSome { value ->
             val variable = convertToPath(value)

usvm-dataflow/src/main/kotlin/org/usvm/dataflow/config/Position.kt

@@ -35,28 +35,30 @@ import org.usvm.dataflow.ifds.fmap
 import org.usvm.dataflow.ifds.toMaybe
 import org.usvm.dataflow.util.Traits
 
-context(Traits<CommonMethod, CommonInst>)
 class CallPositionToAccessPathResolver(
+    private val traits: Traits<CommonMethod, CommonInst>,
     private val callStatement: CommonInst,
 ) : PositionResolver<Maybe<AccessPath>> {
-    private val callExpr = getCallExpr(callStatement)
+    private val callExpr = traits.getCallExpr(callStatement)
         ?: error("Call statement should have non-null callExpr")
 
-    override fun resolve(position: Position): Maybe<AccessPath> = when (position) {
-        AnyArgument -> Maybe.none()
-        is Argument -> convertToPathOrNull(callExpr.args[position.index]).toMaybe()
-        This -> (callExpr as? CommonInstanceCallExpr)?.instance?.let { convertToPathOrNull(it) }.toMaybe()
-        Result -> (callStatement as? CommonAssignInst)?.lhv?.let { convertToPathOrNull(it) }.toMaybe()
-        ResultAnyElement -> (callStatement as? CommonAssignInst)?.lhv?.let { convertToPathOrNull(it) }.toMaybe()
-            .fmap { it + ElementAccessor }
+    override fun resolve(position: Position): Maybe<AccessPath> = with(traits) {
+        when (position) {
+            AnyArgument -> Maybe.none()
+            is Argument -> convertToPathOrNull(callExpr.args[position.index]).toMaybe()
+            This -> (callExpr as? CommonInstanceCallExpr)?.instance?.let { convertToPathOrNull(it) }.toMaybe()
+            Result -> (callStatement as? CommonAssignInst)?.lhv?.let { convertToPathOrNull(it) }.toMaybe()
+            ResultAnyElement -> (callStatement as? CommonAssignInst)?.lhv?.let { convertToPathOrNull(it) }.toMaybe()
+                .fmap { it + ElementAccessor }
+        }
     }
 }
 
-context(Traits<CommonMethod, CommonInst>)
 class CallPositionToValueResolver(
+    traits: Traits<CommonMethod, CommonInst>,
     private val callStatement: CommonInst,
 ) : PositionResolver<Maybe<CommonValue>> {
-    private val callExpr = getCallExpr(callStatement)
+    private val callExpr = traits.getCallExpr(callStatement)
         ?: error("Call statement should have non-null callExpr")
 
     override fun resolve(position: Position): Maybe<CommonValue> = when (position) {
@@ -68,34 +70,38 @@ class CallPositionToValueResolver(
     }
 }
 
-context(Traits<CommonMethod, CommonInst>)
 class EntryPointPositionToValueResolver(
+    private val traits: Traits<CommonMethod, CommonInst>,
     private val method: CommonMethod,
 ) : PositionResolver<Maybe<CommonValue>> {
-    override fun resolve(position: Position): Maybe<CommonValue> = when (position) {
-        This -> Maybe.some(getThisInstance(method))
+    override fun resolve(position: Position): Maybe<CommonValue> = with(traits) {
+        when (position) {
+            This -> Maybe.some(getThisInstance(method))
 
-        is Argument -> {
-            val p = method.parameters[position.index]
-            getArgument(p).toMaybe()
-        }
+            is Argument -> {
+                val p = method.parameters[position.index]
+                getArgument(p).toMaybe()
+            }
 
-        AnyArgument, Result, ResultAnyElement -> error("Unexpected $position")
+            AnyArgument, Result, ResultAnyElement -> error("Unexpected $position")
+        }
     }
 }
 
-context(Traits<CommonMethod, CommonInst>)
 class EntryPointPositionToAccessPathResolver(
+    private val traits: Traits<CommonMethod, CommonInst>,
     private val method: CommonMethod,
 ) : PositionResolver<Maybe<AccessPath>> {
-    override fun resolve(position: Position): Maybe<AccessPath> = when (position) {
-        This -> convertToPathOrNull(getThisInstance(method)).toMaybe()
+    override fun resolve(position: Position): Maybe<AccessPath> = with(traits) {
+        when (position) {
+            This -> convertToPathOrNull(getThisInstance(method)).toMaybe()
 
-        is Argument -> {
-            val p = method.parameters[position.index]
-            getArgument(p)?.let { convertToPathOrNull(it) }.toMaybe()
-        }
+            is Argument -> {
+                val p = method.parameters[position.index]
+                getArgument(p)?.let { convertToPathOrNull(it) }.toMaybe()
+            }
 
-        AnyArgument, Result, ResultAnyElement -> error("Unexpected $position")
+            AnyArgument, Result, ResultAnyElement -> error("Unexpected $position")
+        }
     }
 }

usvm-dataflow/src/main/kotlin/org/usvm/dataflow/ifds/Runner.kt

@@ -41,8 +41,8 @@ interface Runner<Fact, Method, Statement>
     fun getIfdsResult(): IfdsResult<Fact, Statement>
 }
 
-context(Traits<Method, Statement>)
 class UniRunner<Fact, Event, Method, Statement>(
+    private val traits: Traits<Method, Statement>,
     private val manager: Manager<Fact, Event, Method, Statement>,
     override val graph: ApplicationGraph<Method, Statement>,
     private val analyzer: Analyzer<Fact, Event, Method, Statement>,
@@ -139,7 +139,7 @@ class UniRunner<Fact, Event, Method, Statement>(
     private fun tabulationAlgorithmStep(
         currentEdge: Edge<Fact, Statement>,
         scope: CoroutineScope,
-    ) {
+    ) = with(traits) {
         val (startVertex, currentVertex) = currentEdge
         val (current, currentFact) = currentVertex
 

usvm-dataflow/src/main/kotlin/org/usvm/dataflow/sarif/Sarif.kt

@@ -42,8 +42,8 @@ private const val JACODB_INFORMATION_URI =
     "https://github.com/UnitTestBot/jacodb/blob/develop/jacodb-analysis/README.md"
 private const val DEFAULT_PATH_COUNT = 3
 
-context(Traits<*, Statement>)
 fun <Statement : CommonInst> sarifReportFromVulnerabilities(
+    traits: Traits<*, Statement>,
     vulnerabilities: List<VulnerabilityInstance<*, Statement>>,
     maxPathsCount: Int = DEFAULT_PATH_COUNT,
     isDeduplicate: Boolean = true,
@@ -71,14 +71,15 @@ fun <Statement : CommonInst> sarifReportFromVulnerabilities(
                         level = instance.description.level,
                         locations = listOfNotNull(
                             instToSarifLocation(
+                                traits,
                                 instance.traceGraph.sink.statement,
                                 sourceFileResolver
                             )
                         ),
                         codeFlows = instance.traceGraph
                             .getAllTraces()
                             .take(maxPathsCount)
-                            .map { traceToSarifCodeFlow(it, sourceFileResolver, isDeduplicate) }
+                            .map { traceToSarifCodeFlow(traits, it, sourceFileResolver, isDeduplicate) }
                             .toList(),
                     )
                 }
@@ -87,11 +88,11 @@ fun <Statement : CommonInst> sarifReportFromVulnerabilities(
     )
 }
 
-context(Traits<*, Statement>)
 private fun <Statement : CommonInst> instToSarifLocation(
+    traits: Traits<*, Statement>,
     inst: Statement,
     sourceFileResolver: SourceFileResolver<Statement>,
-): Location? {
+): Location? = with(traits) {
     val sourceLocation = sourceFileResolver.resolve(inst) ?: return null
     return Location(
         physicalLocation = PhysicalLocation(
@@ -110,8 +111,8 @@ private fun <Statement : CommonInst> instToSarifLocation(
     )
 }
 
-context(Traits<*, Statement>)
 private fun <Statement : CommonInst> traceToSarifCodeFlow(
+    traits: Traits<*, Statement>,
     trace: List<Vertex<*, Statement>>,
     sourceFileResolver: SourceFileResolver<Statement>,
     isDeduplicate: Boolean = true,
@@ -121,7 +122,7 @@ private fun <Statement : CommonInst> traceToSarifCodeFlow(
             ThreadFlow(
                 locations = trace.map {
                     ThreadFlowLocation(
-                        location = instToSarifLocation(it.statement, sourceFileResolver),
+                        location = instToSarifLocation(traits, it.statement, sourceFileResolver),
                         state = mapOf(
                             "fact" to MultiformatMessageString(
                                 text = it.fact.toString()