Updates rules_kotlin to support Kotlin v2.2.20

ryanulep · ryanulep · commit 61340fe0a20f · 2025-10-09T12:04:32.000Z
diff --git a/kotlin/internal/toolchains.bzl b/kotlin/internal/toolchains.bzl
@@ -134,7 +134,7 @@ _kt_toolchain = rule(
         ),
         "language_version": attr.string(
             doc = "this is the -language_version flag [see](https://kotlinlang.org/docs/reference/compatibility.html)",
-            default = "2.1",
+            default = "2.2",
             values = [
                 "1.1",
                 "1.2",
@@ -147,11 +147,12 @@ _kt_toolchain = rule(
                 "1.9",
                 "2.0",
                 "2.1",
+		"2.2",
             ],
         ),
         "api_version": attr.string(
             doc = "this is the -api_version flag [see](https://kotlinlang.org/docs/reference/compatibility.html).",
-            default = "2.1",
+            default = "2.2",
             values = [
                 "1.1",
                 "1.2",
@@ -164,6 +165,7 @@ _kt_toolchain = rule(
                 "1.9",
                 "2.0",
                 "2.1",
+		"2.2",
             ],
         ),
         "debug": attr.string_list(
diff --git a/src/main/kotlin/bootstrap.bzl b/src/main/kotlin/bootstrap.bzl
@@ -37,6 +37,9 @@ def kt_bootstrap_library(name, deps = [], neverlink_deps = [], srcs = [], visibi
         **kwargs
     )
 
+    # Filter out kotlinc_opts from kwargs for ktlint rules (they don't support it)
+    ktlint_kwargs = {k: v for k, v in kwargs.items() if k != "kotlinc_opts"}
+
     _ktlint_test(
         name = "%s_ktlint_test" % name,
         srcs = srcs,
@@ -51,7 +54,7 @@ def kt_bootstrap_library(name, deps = [], neverlink_deps = [], srcs = [], visibi
         visibility = ["//visibility:private"],
         config = "//:ktlint_editorconfig",
         tags = ["no-ide", "ktlint"],
-        **kwargs
+        **ktlint_kwargs
     )
 
 def kt_bootstrap_binary(
diff --git a/src/main/kotlin/io/bazel/kotlin/generate/BUILD.bazel b/src/main/kotlin/io/bazel/kotlin/generate/BUILD.bazel
@@ -12,7 +12,6 @@ kt_jvm_import(
         "//kotlin/compiler:kotlin-stdlib-jdk7",
         "//kotlin/compiler:kotlin-stdlib-jdk8",
         "//kotlin/compiler:kotlinx-coroutines-core-jvm",
-        "//kotlin/compiler:trove4j",
     ],
 )
 
diff --git a/src/main/kotlin/io/bazel/kotlin/plugin/jdeps/BUILD.bazel b/src/main/kotlin/io/bazel/kotlin/plugin/jdeps/BUILD.bazel
@@ -25,6 +25,9 @@ kt_bootstrap_library(
         "k2/checker/declaration/*.kt",
         "k2/checker/expression/*.kt",
     ]),
+    kotlinc_opts = {
+        "-Xcontext-receivers": "",
+    },
     visibility = ["//src:__subpackages__"],
     deps = [
         "//kotlin/compiler:kotlin-compiler",
diff --git a/src/main/kotlin/io/bazel/kotlin/plugin/jdeps/k2/checker/declaration/BasicDeclarationChecker.kt b/src/main/kotlin/io/bazel/kotlin/plugin/jdeps/k2/checker/declaration/BasicDeclarationChecker.kt
@@ -11,14 +11,13 @@ import org.jetbrains.kotlin.fir.declarations.toAnnotationClassLikeSymbol
 internal class BasicDeclarationChecker(
   private val classUsageRecorder: ClassUsageRecorder,
 ) : FirBasicDeclarationChecker(MppCheckerKind.Common) {
+  context(CheckerContext, DiagnosticReporter)
   override fun check(
     declaration: FirDeclaration,
-    context: CheckerContext,
-    reporter: DiagnosticReporter,
   ) {
     declaration.annotations.forEach { annotation ->
-      annotation.toAnnotationClassLikeSymbol(context.session)?.let {
-        classUsageRecorder.recordClass(it, context)
+      annotation.toAnnotationClassLikeSymbol(this@CheckerContext.session)?.let {
+        classUsageRecorder.recordClass(it, this@CheckerContext)
       }
     }
   }
diff --git a/src/main/kotlin/io/bazel/kotlin/plugin/jdeps/k2/checker/declaration/CallableChecker.kt b/src/main/kotlin/io/bazel/kotlin/plugin/jdeps/k2/checker/declaration/CallableChecker.kt
@@ -16,25 +16,24 @@ internal class CallableChecker(
    * Tracks the return type & type parameters of a callable declaration. Function parameters are
    * tracked in [FunctionChecker].
    */
+  context(CheckerContext, DiagnosticReporter)
   override fun check(
     declaration: FirCallableDeclaration,
-    context: CheckerContext,
-    reporter: DiagnosticReporter,
   ) {
     // return type
-    declaration.returnTypeRef.let { classUsageRecorder.recordTypeRef(it, context) }
+    declaration.returnTypeRef.let { classUsageRecorder.recordTypeRef(it, this@CheckerContext) }
 
     // type params
     declaration.typeParameters.forEach { typeParam ->
       typeParam.symbol.resolvedBounds.forEach { typeParamBound ->
-        typeParamBound.let { classUsageRecorder.recordTypeRef(it, context) }
+        typeParamBound.let { classUsageRecorder.recordTypeRef(it, this@CheckerContext) }
       }
     }
 
     // receiver param for extensions
     if (declaration !is FirAnonymousFunction) {
       declaration.receiverParameter?.typeRef?.let {
-        classUsageRecorder.recordTypeRef(it, context, isExplicit = declaration.isExtension)
+        classUsageRecorder.recordTypeRef(it, this@CheckerContext, isExplicit = declaration.isExtension)
       }
     }
   }
diff --git a/src/main/kotlin/io/bazel/kotlin/plugin/jdeps/k2/checker/declaration/ClassLikeChecker.kt b/src/main/kotlin/io/bazel/kotlin/plugin/jdeps/k2/checker/declaration/ClassLikeChecker.kt
@@ -11,15 +11,14 @@ import org.jetbrains.kotlin.fir.resolve.getSuperTypes
 internal class ClassLikeChecker(
   private val classUsageRecorder: ClassUsageRecorder,
 ) : FirClassLikeChecker(MppCheckerKind.Common) {
+  context(CheckerContext, DiagnosticReporter)
   override fun check(
     declaration: FirClassLikeDeclaration,
-    context: CheckerContext,
-    reporter: DiagnosticReporter,
   ) {
-    declaration.symbol.let { classUsageRecorder.recordClass(it, context) }
+    declaration.symbol.let { classUsageRecorder.recordClass(it, this@CheckerContext) }
     // [recordClass] also handles supertypes, but this marks direct supertypes as explicit
-    declaration.symbol.getSuperTypes(context.session, recursive = false).forEach {
-      classUsageRecorder.recordConeType(it, context)
+    declaration.symbol.getSuperTypes(this@CheckerContext.session, recursive = false).forEach {
+      classUsageRecorder.recordConeType(it, this@CheckerContext)
     }
   }
 }
diff --git a/src/main/kotlin/io/bazel/kotlin/plugin/jdeps/k2/checker/declaration/FileChecker.kt b/src/main/kotlin/io/bazel/kotlin/plugin/jdeps/k2/checker/declaration/FileChecker.kt
@@ -22,26 +22,25 @@ import org.jetbrains.kotlin.name.ClassId
 internal class FileChecker(
   private val classUsageRecorder: ClassUsageRecorder,
 ) : FirFileChecker(MppCheckerKind.Common) {
+  context(CheckerContext, DiagnosticReporter)
   override fun check(
     declaration: FirFile,
-    context: CheckerContext,
-    reporter: DiagnosticReporter,
   ) {
     declaration.imports.filterIsInstance<FirResolvedImport>().forEach { import ->
       // check for classlike import (class, interface, object, enum, annotation, etc)
-      if (import.resolvesToClass(context)) {
-        import.classId()?.resolveToClass(context)?.let {
-          classUsageRecorder.recordClass(it, context)
+      if (import.resolvesToClass(this@CheckerContext)) {
+        import.classId()?.resolveToClass(this@CheckerContext)?.let {
+          classUsageRecorder.recordClass(it, this@CheckerContext)
         }
       } else {
         // check for function import
-        val callableBinaryClass = import.resolveToFun(context)?.containerSource?.binaryClass()
+        val callableBinaryClass = import.resolveToFun(this@CheckerContext)?.containerSource?.binaryClass()
         if (callableBinaryClass != null) {
           classUsageRecorder.recordClass(callableBinaryClass)
         } else {
           // for other symbols, track the parent class
-          import.resolvedParentClassId?.resolveToClass(context)?.let {
-            classUsageRecorder.recordClass(it, context)
+          import.resolvedParentClassId?.resolveToClass(this@CheckerContext)?.let {
+            classUsageRecorder.recordClass(it, this@CheckerContext)
           }
         }
       }
diff --git a/src/main/kotlin/io/bazel/kotlin/plugin/jdeps/k2/checker/declaration/FunctionChecker.kt b/src/main/kotlin/io/bazel/kotlin/plugin/jdeps/k2/checker/declaration/FunctionChecker.kt
@@ -14,14 +14,13 @@ internal class FunctionChecker(
    * Tracks the value parameters of a function declaration. Return type & type parameters are
    * tracked in [CallableChecker].
    */
+  context(CheckerContext, DiagnosticReporter)
   override fun check(
     declaration: FirFunction,
-    context: CheckerContext,
-    reporter: DiagnosticReporter,
   ) {
     // function parameters
     declaration.valueParameters.forEach { valueParam ->
-      valueParam.returnTypeRef.let { classUsageRecorder.recordTypeRef(it, context) }
+      valueParam.returnTypeRef.let { classUsageRecorder.recordTypeRef(it, this@CheckerContext) }
     }
   }
 }
diff --git a/src/main/kotlin/io/bazel/kotlin/plugin/jdeps/k2/checker/expression/QualifiedAccessChecker.kt b/src/main/kotlin/io/bazel/kotlin/plugin/jdeps/k2/checker/expression/QualifiedAccessChecker.kt
@@ -21,10 +21,9 @@ import org.jetbrains.kotlin.KtSourceElement
 internal class QualifiedAccessChecker(
   private val classUsageRecorder: ClassUsageRecorder,
 ) : FirQualifiedAccessExpressionChecker(MppCheckerKind.Common) {
+  context(CheckerContext, DiagnosticReporter)
   override fun check(
     expression: FirQualifiedAccessExpression,
-    context: CheckerContext,
-    reporter: DiagnosticReporter,
   ) {
     // track function's owning class
     val resolvedCallableSymbol = expression.toResolvedCallableSymbol()
@@ -37,15 +36,15 @@ internal class QualifiedAccessChecker(
     resolvedCallableSymbol?.resolvedReturnTypeRef?.let {
       classUsageRecorder.recordTypeRef(
         it,
-        context,
+        this@CheckerContext,
         isExplicit = isExplicitReturnType,
         collectTypeArguments = false,
       )
     }
 
     // type arguments
     resolvedCallableSymbol?.typeParameterSymbols?.forEach { typeParam ->
-      typeParam.resolvedBounds.forEach { classUsageRecorder.recordTypeRef(it, context) }
+      typeParam.resolvedBounds.forEach { classUsageRecorder.recordTypeRef(it, this@CheckerContext) }
     }
 
     // track fun parameter types based on referenced function
@@ -54,18 +53,18 @@ internal class QualifiedAccessChecker(
       ?.valueParameterSymbols
       ?.forEach { valueParam ->
         valueParam.resolvedReturnTypeRef.let {
-          classUsageRecorder.recordTypeRef(it, context, isExplicit = false)
+          classUsageRecorder.recordTypeRef(it, this@CheckerContext, isExplicit = false)
         }
       }
     // track fun arguments actually passed
     (expression as? FirFunctionCall)?.arguments?.map { it.resolvedType }?.forEach {
-      classUsageRecorder.recordConeType(it, context, isExplicit = !it.isExtensionFunctionType)
+      classUsageRecorder.recordConeType(it, this@CheckerContext, isExplicit = !it.isExtensionFunctionType)
     }
 
     // track dispatch receiver
     expression.dispatchReceiver?.resolvedType?.let {
       if (!it.isUnit) {
-        classUsageRecorder.recordConeType(it, context, isExplicit = false)
+        classUsageRecorder.recordConeType(it, this@CheckerContext, isExplicit = false)
       }
     }
 
diff --git a/src/main/kotlin/io/bazel/kotlin/plugin/jdeps/k2/checker/expression/ResolvedQualifierChecker.kt b/src/main/kotlin/io/bazel/kotlin/plugin/jdeps/k2/checker/expression/ResolvedQualifierChecker.kt
@@ -11,13 +11,12 @@ import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
 internal class ResolvedQualifierChecker(
   private val classUsageRecorder: ClassUsageRecorder,
 ) : FirResolvedQualifierChecker(MppCheckerKind.Common) {
+  context(CheckerContext, DiagnosticReporter)
   override fun check(
     expression: FirResolvedQualifier,
-    context: CheckerContext,
-    reporter: DiagnosticReporter,
   ) {
     expression.symbol?.let {
-      classUsageRecorder.recordClass(it, context)
+      classUsageRecorder.recordClass(it, this@CheckerContext)
     }
   }
 }
diff --git a/src/main/starlark/core/compile/cli/BUILD.bazel b/src/main/starlark/core/compile/cli/BUILD.bazel
@@ -26,7 +26,6 @@ cli_toolchain(
         "//kotlin/compiler:kotlin-stdlib-jdk7",
         "//kotlin/compiler:kotlin-stdlib-jdk8",
         "//kotlin/compiler:kotlinx-coroutines-core-jvm",
-        "//kotlin/compiler:trove4j",
     ],
     kotlinc = ":kotlinc",
     language_version = versions.KOTLIN_CURRENT_COMPILER_RELEASE.version,
diff --git a/src/main/starlark/core/compile/cli/compile.bzl b/src/main/starlark/core/compile/cli/compile.bzl
@@ -42,7 +42,10 @@ def compile_kotlin_for_jvm(
     args.add("-module-name", module_name)
     args.add_joined("-cp", classpath, join_with = path_separator)
     for (k, v) in kotlinc_opts.items():
-        args.add(k, v)
+        if v:
+            args.add(k, v)
+        else:
+            args.add(k)
     args.add_all(srcs)
 
     actions.run(
diff --git a/src/main/starlark/core/options/opts.kotlinc.bzl b/src/main/starlark/core/options/opts.kotlinc.bzl
@@ -82,6 +82,17 @@ _KOPTS_ALL = {
             True: ["-Xcontext-receivers"],
         },
     ),
+    "x_context_parameters": struct(
+        flag = "-Xcontext-parameters",
+        args = dict(
+            default = False,
+            doc = "Enable experimental context parameters (supersedes context receivers).",
+        ),
+        type = attr.bool,
+        value_to_flag = {
+            True: ["-Xcontext-parameters"],
+        },
+    ),
     "x_suppress_version_warnings": struct(
         flag = "-Xsuppress-version-warnings",
         args = dict(
diff --git a/src/main/starlark/core/repositories/kotlin/artifacts.bzl b/src/main/starlark/core/repositories/kotlin/artifacts.bzl
@@ -65,7 +65,6 @@ KOTLINC_ARTIFACTS = struct(
             "kotlinx-coroutines-core-jvm": "lib/kotlinx-coroutines-core-jvm.jar",
             "parcelize-compiler": "lib/parcelize-compiler.jar",
             "scripting-compiler": "lib/scripting-compiler.jar",
-            "trove4j": "lib/trove4j.jar",
         },
     ),
 )
diff --git a/src/main/starlark/core/repositories/kotlin/capabilities_2.2.bzl.com_github_jetbrains_kotlin.bazel b/src/main/starlark/core/repositories/kotlin/capabilities_2.2.bzl.com_github_jetbrains_kotlin.bazel
diff --git a/src/main/starlark/core/repositories/versions.bzl b/src/main/starlark/core/repositories/versions.bzl

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,6 @@ kt_jvm_import(`
`12`	`12`	`"//kotlin/compiler:kotlin-stdlib-jdk7",`
`13`	`13`	`"//kotlin/compiler:kotlin-stdlib-jdk8",`
`14`	`14`	`"//kotlin/compiler:kotlinx-coroutines-core-jvm",`
`15`		`- "//kotlin/compiler:trove4j",`
`16`	`15`	`],`
`17`	`16`	`)`
`18`	`17`
Original file line number	Diff line number	Diff line change
`@@ -11,14 +11,13 @@ import org.jetbrains.kotlin.fir.declarations.toAnnotationClassLikeSymbol`
`11`	`11`	`internal class BasicDeclarationChecker(`
`12`	`12`	`private val classUsageRecorder: ClassUsageRecorder,`
`13`	`13`	`) : FirBasicDeclarationChecker(MppCheckerKind.Common) {`
	`14`	`+ context(CheckerContext, DiagnosticReporter)`
`14`	`15`	`override fun check(`
`15`	`16`	`declaration: FirDeclaration,`
`16`		`- context: CheckerContext,`
`17`		`- reporter: DiagnosticReporter,`
`18`	`17`	`) {`
`19`	`18`	`declaration.annotations.forEach { annotation ->`
`20`		`- annotation.toAnnotationClassLikeSymbol(context.session)?.let {`
`21`		`- classUsageRecorder.recordClass(it, context)`
	`19`	`+ annotation.toAnnotationClassLikeSymbol(this@CheckerContext.session)?.let {`
	`20`	`+ classUsageRecorder.recordClass(it, this@CheckerContext)`
`22`	`21`	`}`
`23`	`22`	`}`
`24`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,25 +16,24 @@ internal class CallableChecker(`
`16`	`16`	`* Tracks the return type & type parameters of a callable declaration. Function parameters are`
`17`	`17`	`* tracked in [FunctionChecker].`
`18`	`18`	`*/`
	`19`	`+ context(CheckerContext, DiagnosticReporter)`
`19`	`20`	`override fun check(`
`20`	`21`	`declaration: FirCallableDeclaration,`
`21`		`- context: CheckerContext,`
`22`		`- reporter: DiagnosticReporter,`
`23`	`22`	`) {`
`24`	`23`	`// return type`
`25`		`- declaration.returnTypeRef.let { classUsageRecorder.recordTypeRef(it, context) }`
	`24`	`+ declaration.returnTypeRef.let { classUsageRecorder.recordTypeRef(it, this@CheckerContext) }`
`26`	`25`
`27`	`26`	`// type params`
`28`	`27`	`declaration.typeParameters.forEach { typeParam ->`
`29`	`28`	`typeParam.symbol.resolvedBounds.forEach { typeParamBound ->`
`30`		`- typeParamBound.let { classUsageRecorder.recordTypeRef(it, context) }`
	`29`	`+ typeParamBound.let { classUsageRecorder.recordTypeRef(it, this@CheckerContext) }`
`31`	`30`	`}`
`32`	`31`	`}`
`33`	`32`
`34`	`33`	`// receiver param for extensions`
`35`	`34`	`if (declaration !is FirAnonymousFunction) {`
`36`	`35`	`declaration.receiverParameter?.typeRef?.let {`
`37`		`- classUsageRecorder.recordTypeRef(it, context, isExplicit = declaration.isExtension)`
	`36`	`+ classUsageRecorder.recordTypeRef(it, this@CheckerContext, isExplicit = declaration.isExtension)`
`38`	`37`	`}`
`39`	`38`	`}`
`40`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,14 +14,13 @@ internal class FunctionChecker(`
`14`	`14`	`* Tracks the value parameters of a function declaration. Return type & type parameters are`
`15`	`15`	`* tracked in [CallableChecker].`
`16`	`16`	`*/`
	`17`	`+ context(CheckerContext, DiagnosticReporter)`
`17`	`18`	`override fun check(`
`18`	`19`	`declaration: FirFunction,`
`19`		`- context: CheckerContext,`
`20`		`- reporter: DiagnosticReporter,`
`21`	`20`	`) {`
`22`	`21`	`// function parameters`
`23`	`22`	`declaration.valueParameters.forEach { valueParam ->`
`24`		`- valueParam.returnTypeRef.let { classUsageRecorder.recordTypeRef(it, context) }`
	`23`	`+ valueParam.returnTypeRef.let { classUsageRecorder.recordTypeRef(it, this@CheckerContext) }`
`25`	`24`	`}`
`26`	`25`	`}`
`27`	`26`	`}`