Kotlin: extract context parameters from 2.2.20

Use the unified parameter and argument layout introduced in Kotlin 2.2.20-Beta2 so context parameters and their implicit call arguments are included before the old accessors disappear in Kotlin 2.4.\n\nAssign parameter indices after excluding receiver slots, and give compiler-generated context arguments a stable whole-file location when the earlier compiler supplies inconsistent offsets. This fixes the version-gated function, getter, and setter regression test without changing its expected output. Earlier compilers retain the legacy compatibility implementation because they do not accept the tested context-parameter syntax.\n\nCo-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

java/kotlin-extractor/src/main/kotlin/KotlinFileExtractor.kt

@@ -3590,7 +3590,9 @@ open class KotlinFileExtractor(
                         valueArguments,
                         enclosingStmt,
                         enclosingCallable,
-                        idxOffset
+                        idxOffset,
+                        valueParameters = syntacticCallTarget.codeQlValueParameters,
+                        invalidArgumentLocation = tw.getWholeFileLocation()
                     )
                 },
                 dispatchReceiver?.type,
@@ -3804,50 +3806,93 @@ open class KotlinFileExtractor(
         enclosingStmt: Label<out DbStmt>,
         enclosingCallable: Label<out DbCallable>,
         idxOffset: Int
-    ) =
+    ) {
         extractCallValueArguments(
             callId,
             (0 until call.codeQlValueArgumentsCount).map { call.codeQlGetValueArgument(it) },
             enclosingStmt,
             enclosingCallable,
-            idxOffset
+            idxOffset,
+            valueParameters = call.symbol.owner.codeQlValueParameters,
+            invalidArgumentLocation = tw.getWholeFileLocation()
         )
+    }
 
     private fun extractCallValueArguments(
         callId: Label<out DbExprparent>,
         valueArguments: List<IrExpression?>,
         enclosingStmt: Label<out DbStmt>,
         enclosingCallable: Label<out DbCallable>,
         idxOffset: Int,
-        extractVarargAsArray: Boolean = false
+        extractVarargAsArray: Boolean = false,
+        valueParameters: List<IrValueParameter>? = null,
+        invalidArgumentLocation: Label<DbLocation>? = null
     ) {
         var i = 0
-        valueArguments.forEach { arg ->
+        valueArguments.forEachIndexed { argumentIndex, arg ->
             if (arg != null) {
-                if (arg is IrVararg && !extractVarargAsArray) {
-                    arg.elements.forEachIndexed { varargNo, vararg ->
-                        extractVarargElement(
-                            vararg,
-                            enclosingCallable,
-                            callId,
-                            i + idxOffset + varargNo,
-                            enclosingStmt
-                        )
-                    }
-                    i += arg.elements.size
-                } else {
-                    extractExpressionExpr(
-                        arg,
-                        enclosingCallable,
+                val parameter = valueParameters?.getOrNull(argumentIndex)
+                if (
+                    parameter?.isCodeQlContextParameter() == true &&
+                        arg is IrGetValue &&
+                        (arg.startOffset < 0 || arg.endOffset < 0) &&
+                        invalidArgumentLocation != null
+                ) {
+                    extractVariableAccess(
+                        useValueDeclaration(arg.symbol.owner),
+                        arg.type,
+                        invalidArgumentLocation,
                         callId,
-                        (i++) + idxOffset,
+                        i++ + idxOffset,
+                        enclosingCallable,
                         enclosingStmt
                     )
+                } else {
+                    i +=
+                        extractCallValueArgument(
+                            callId,
+                            arg,
+                            enclosingStmt,
+                            enclosingCallable,
+                            i + idxOffset,
+                            extractVarargAsArray
+                        )
                 }
             }
         }
     }
 
+    private fun extractCallValueArgument(
+        callId: Label<out DbExprparent>,
+        argument: IrExpression,
+        enclosingStmt: Label<out DbStmt>,
+        enclosingCallable: Label<out DbCallable>,
+        outputIndex: Int,
+        extractVarargAsArray: Boolean = false
+    ): Int {
+        if (argument is IrVararg && !extractVarargAsArray) {
+            argument.elements.forEachIndexed { varargIndex, element ->
+                extractVarargElement(
+                    element,
+                    enclosingCallable,
+                    callId,
+                    outputIndex + varargIndex,
+                    enclosingStmt
+                )
+            }
+            return argument.elements.size
+        }
+
+        extractExpressionExpr(
+            argument,
+            enclosingCallable,
+            callId,
+            outputIndex,
+            enclosingStmt
+        )
+        return 1
+    }
+
     private fun findFunction(cls: IrClass, name: String): IrFunction? =
         cls.declarations.findSubType<IrFunction> { it.name.asString() == name }
 

java/kotlin-extractor/src/main/kotlin/utils/versions/v_1_8_0/isCodeQlContextParameter.kt

@@ -0,0 +1,5 @@
+package com.github.codeql.utils.versions
+
+import org.jetbrains.kotlin.ir.declarations.IrValueParameter
+
+fun IrValueParameter.isCodeQlContextParameter() = false

java/kotlin-extractor/src/main/kotlin/utils/versions/v_2_2_20-Beta2/IrCompat.kt

@@ -0,0 +1,82 @@
+package com.github.codeql.utils.versions
+
+import org.jetbrains.kotlin.ir.declarations.IrFunction
+import org.jetbrains.kotlin.ir.declarations.IrMutableAnnotationContainer
+import org.jetbrains.kotlin.ir.declarations.IrParameterKind
+import org.jetbrains.kotlin.ir.declarations.IrValueParameter
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
+import org.jetbrains.kotlin.ir.expressions.IrExpression
+import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression
+import org.jetbrains.kotlin.ir.expressions.impl.IrConstructorCallImpl
+import org.jetbrains.kotlin.ir.expressions.impl.fromSymbolOwner
+import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
+import org.jetbrains.kotlin.ir.types.IrType
+import org.jetbrains.kotlin.ir.types.addAnnotations
+
+private fun IrParameterKind.isCodeQlValueParameter() =
+    this == IrParameterKind.Context || this == IrParameterKind.Regular
+
+val IrFunction.codeQlValueParameters: List<IrValueParameter>
+    get() = parameters.filter { it.kind.isCodeQlValueParameter() }
+
+val IrFunction.codeQlExtensionReceiverParameter: IrValueParameter?
+    get() = extensionReceiverParameter
+
+private fun IrMemberAccessExpression<*>.valueArgumentIndices(): List<Int> {
+    val owner = symbol.owner as? IrFunction ?: return arguments.indices.toList()
+    return owner.parameters.mapIndexedNotNull { index, parameter ->
+        index.takeIf { parameter.kind.isCodeQlValueParameter() }
+    }
+}
+
+val IrMemberAccessExpression<*>.codeQlValueArgumentsCount: Int
+    get() = valueArgumentIndices().size
+
+fun IrMemberAccessExpression<*>.codeQlGetValueArgument(index: Int): IrExpression? =
+    arguments[valueArgumentIndices()[index]]
+
+fun IrMemberAccessExpression<*>.codeQlPutValueArgument(index: Int, value: IrExpression?) {
+    arguments[valueArgumentIndices()[index]] = value
+}
+
+val IrMemberAccessExpression<*>.codeQlExtensionReceiver: IrExpression?
+    get() = extensionReceiver
+
+val IrMemberAccessExpression<*>.codeQlTypeArgumentsCount: Int
+    get() = typeArgumentsCount
+
+fun IrMemberAccessExpression<*>.codeQlGetTypeArgument(index: Int): IrType? = getTypeArgument(index)
+
+fun IrType.codeQlAddAnnotations(annotations: List<IrConstructorCall>): IrType =
+    addAnnotations(annotations)
+
+fun codeQlSetAnnotations(
+    container: IrMutableAnnotationContainer,
+    annotations: List<IrConstructorCall>
+) {
+    container.annotations = annotations
+}
+
+fun IrFunction.codeQlSetDispatchReceiverParameter(param: IrValueParameter?) {
+    dispatchReceiverParameter = param
+}
+
+fun codeQlAnnotationFromSymbolOwner(
+    startOffset: Int,
+    endOffset: Int,
+    type: IrType,
+    symbol: IrConstructorSymbol,
+    typeArgumentsCount: Int
+): IrConstructorCall =
+    IrConstructorCallImpl.fromSymbolOwner(
+        startOffset,
+        endOffset,
+        type,
+        symbol,
+        typeArgumentsCount
+    )
+
+fun codeQlAnnotationFromSymbolOwner(
+    type: IrType,
+    symbol: IrConstructorSymbol
+): IrConstructorCall = IrConstructorCallImpl.fromSymbolOwner(type, symbol)

java/kotlin-extractor/src/main/kotlin/utils/versions/v_2_2_20-Beta2/isCodeQlContextParameter.kt

@@ -0,0 +1,6 @@
+package com.github.codeql.utils.versions
+
+import org.jetbrains.kotlin.ir.declarations.IrParameterKind
+import org.jetbrains.kotlin.ir.declarations.IrValueParameter
+
+fun IrValueParameter.isCodeQlContextParameter() = kind == IrParameterKind.Context

java/kotlin-extractor/src/main/kotlin/utils/versions/v_2_2_20-Beta2/parameterIndexExcludingReceivers.kt

@@ -0,0 +1,19 @@
+package com.github.codeql.utils.versions
+
+import org.jetbrains.kotlin.ir.declarations.IrFunction
+import org.jetbrains.kotlin.ir.declarations.IrParameterKind
+import org.jetbrains.kotlin.ir.declarations.IrValueParameter
+
+fun parameterIndexExcludingReceivers(vp: IrValueParameter): Int {
+    if (
+        vp.kind == IrParameterKind.DispatchReceiver ||
+            vp.kind == IrParameterKind.ExtensionReceiver
+    ) {
+        return -1
+    }
+    return (vp.parent as? IrFunction)
+        ?.parameters
+        ?.take(vp.indexInParameters)
+        ?.count { it.kind == IrParameterKind.Context || it.kind == IrParameterKind.Regular }
+        ?: vp.indexInParameters
+}