Merge pull request #130 from lupuuss/kotlin-2.3.20

Kotlin 2.3.20

Author: lupuuss

gradle/libs.versions.toml

@@ -1,12 +1,12 @@
 [versions]
-kotlinMininumSupported="2.3.0"
-kotlin = "2.3.10"
+kotlinMininumSupported = "2.3.0"
+kotlin = "2.3.20-RC"
 kotlinx-coroutines = "1.10.2"
 buildconfig = "5.7.0"
 google-autoservice = "1.1.1"
 atomicfu = "0.31.0"
 dokka = "2.1.0"
-poko = "0.20.2"
+poko = "0.21.1"
 vanniktech-publish-plugin = "0.36.0"
 gradle-portal-publish = "2.0.0"
 

mokkery-plugin/src/main/kotlin/dev/mokkery/plugin/fir/compat/FirCompat.kt

@@ -0,0 +1,20 @@
+package dev.mokkery.plugin.fir.compat
+
+import org.jetbrains.kotlin.descriptors.runtime.components.tryLoadClass
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.declarations.FirFunction
+
+fun FirFunction.isNamedFunctionCompat(): Boolean {
+    if (firNamedFunctionClass != null) return firNamedFunctionClass.isInstance(this)
+    return requireNotNull(firSimpleFunctionClass) { "Incompatible Kotlin compiler version detected!" }.isInstance(this)
+}
+
+fun FirElement.isSimpleFunctionCompat(): Boolean = firSimpleFunctionClass?.isInstance(this) ?: false
+
+private val firNamedFunctionClass = Unit::class.java
+    .classLoader
+    .tryLoadClass("org.jetbrains.kotlin.fir.declarations.FirNamedFunction")
+
+private val firSimpleFunctionClass = Unit::class.java
+    .classLoader
+    .tryLoadClass("org.jetbrains.kotlin.fir.declarations.FirSimpleFunction")

mokkery-plugin/src/main/kotlin/dev/mokkery/plugin/fir/diagnostics/MatchersDeclarationChecker.kt

@@ -2,6 +2,7 @@ package dev.mokkery.plugin.fir.diagnostics
 
 import dev.mokkery.plugin.Mokkery
 import dev.mokkery.plugin.fir.acceptsMatcher
+import dev.mokkery.plugin.fir.compat.isNamedFunctionCompat
 import dev.mokkery.plugin.fir.getMatcherAnnotation
 import dev.mokkery.plugin.fir.isMatcher
 import dev.mokkery.plugin.fir.isMokkeryMatcherScope
@@ -17,7 +18,6 @@ import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirFunctionChecker
 import org.jetbrains.kotlin.fir.declarations.FirFunction
-import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.utils.isExternal
 import org.jetbrains.kotlin.fir.declarations.utils.modality
 import org.jetbrains.kotlin.fir.resolve.defaultType
@@ -67,7 +67,7 @@ class MatchersDeclarationChecker(
 
     context(context: CheckerContext, reporter: DiagnosticReporter)
     private fun checkOrigin(declaration: FirFunction) {
-        if (declaration !is FirSimpleFunction) {
+        if (!declaration.isNamedFunctionCompat()) {
             reporter.reportOn(declaration.source, Diagnostics.MATCHER_MUST_BE_REGULAR_FUNCTION)
         }
     }

mokkery-plugin/src/main/kotlin/dev/mokkery/plugin/fir/diagnostics/MatchersUsageReporterVisitor.kt

@@ -3,6 +3,7 @@ package dev.mokkery.plugin.fir.diagnostics
 import dev.mokkery.plugin.Mokkery.Callable
 import dev.mokkery.plugin.fir.acceptsMatcher
 import dev.mokkery.plugin.fir.allNonDispatchArgumentsMapping
+import dev.mokkery.plugin.fir.compat.isSimpleFunctionCompat
 import dev.mokkery.plugin.fir.extractArrayLiteralCall
 import dev.mokkery.plugin.fir.isSpread
 import org.jetbrains.kotlin.config.CompilerConfiguration
@@ -20,7 +21,7 @@ import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
+import org.jetbrains.kotlin.fir.declarations.FirNamedFunction
 import org.jetbrains.kotlin.fir.declarations.utils.isFinal
 import org.jetbrains.kotlin.fir.expressions.FirBooleanOperatorExpression
 import org.jetbrains.kotlin.fir.expressions.FirDoWhileLoop
@@ -86,11 +87,15 @@ class MatchersUsageReporterVisitor(
     private val callAssociatedLambdas = mutableMapOf<FirFunctionSymbol<*>, FirFunctionCall?>()
     private val legalizedNonMemberFunctionWithMatchers = mutableSetOf<FirFunctionCall>()
 
-    override fun visitElement(element: FirElement) = element.acceptChildren(this)
+    override fun visitElement(element: FirElement) {
+        // backward compat - cannot override removed type so it's handled here
+        if (element is FirFunction && element.isSimpleFunctionCompat()) return visitFunction(element)
+        element.acceptChildren(this)
+    }
 
     override fun visitAnonymousObject(anonymousObject: FirAnonymousObject) {
         nestedClassStack.add(anonymousObject.symbol)
-        super.visitAnonymousObject(anonymousObject)
+        anonymousObject.acceptChildren(this)
         nestedClassStack.popLast()
     }
 
@@ -100,40 +105,40 @@ class MatchersUsageReporterVisitor(
 
     override fun visitClass(klass: FirClass) {
         nestedClassStack.add(klass.symbol)
-        super.visitClass(klass)
+        klass.acceptChildren(this)
         nestedClassStack.popLast()
     }
 
     override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction) {
         functionsStack += anonymousFunction.symbol
         callAssociatedLambdas[anonymousFunction.symbol] = currentCallsStack.lastOrNull()
-        super.visitAnonymousFunction(anonymousFunction)
+        anonymousFunction.acceptChildren(this)
         callAssociatedLambdas.remove(anonymousFunction.symbol)
         functionsStack -= anonymousFunction.symbol
     }
 
-    override fun visitSimpleFunction(simpleFunction: FirSimpleFunction) {
-        visitFunction(simpleFunction)
+    override fun visitNamedFunction(namedFunction: FirNamedFunction) {
+        visitFunction(namedFunction)
     }
 
     override fun visitFunction(function: FirFunction) {
         functionsStack += function.symbol
-        super.visitFunction(function)
+        function.acceptChildren(this)
         functionsStack -= function.symbol
     }
 
     override fun visitProperty(property: FirProperty) {
         matchersProcessor.processVariable(property)
-        super.visitProperty(property)
+        property.acceptChildren(this)
     }
 
     override fun visitVariableAssignment(variableAssignment: FirVariableAssignment) = context(context) {
         val variableSymbol = variableAssignment
             .calleeReference
             ?.toResolvedVariableSymbol()
-            ?: return@context super.visitVariableAssignment(variableAssignment)
-        if (variableAssignment.dispatchReceiver != null) return@context super.visitVariableAssignment(variableAssignment)
-        if (!matchersProcessor.isMatcher(variableAssignment.rValue)) return@context super.visitVariableAssignment(variableAssignment)
+            ?: return@context variableAssignment.acceptChildren(this)
+        if (variableAssignment.dispatchReceiver != null) return@context variableAssignment.acceptChildren(this)
+        if (!matchersProcessor.isMatcher(variableAssignment.rValue)) return@context variableAssignment.acceptChildren(this)
         when (matchersProcessor.getResultFor(variableSymbol)) {
             null -> reporter.reportOn(
                 source = variableAssignment.source,
@@ -147,7 +152,7 @@ class MatchersUsageReporterVisitor(
             )
             else -> Unit
         }
-        return@context super.visitVariableAssignment(variableAssignment)
+        return@context variableAssignment.acceptChildren(this)
     }
 
     override fun visitWhenExpression(whenExpression: FirWhenExpression) = context(context) {
@@ -161,11 +166,12 @@ class MatchersUsageReporterVisitor(
             .forEachMatcher {
                 reporter.reportOn(it.source, Diagnostics.ILLEGAL_MATCHER_IN_CONDITION)
             }
-        super.visitWhenExpression(whenExpression)
+        whenExpression.acceptChildren(this)
     }
 
     override fun visitWhileLoop(whileLoop: FirWhileLoop) {
-        visitLoop(whileLoop)    }
+        visitLoop(whileLoop)
+    }
 
     override fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop) {
         visitLoop(doWhileLoop)
@@ -175,7 +181,7 @@ class MatchersUsageReporterVisitor(
         if (matchersProcessor.isMatcher(loop.condition)) {
             reporter.reportOn(loop.condition.source, Diagnostics.ILLEGAL_MATCHER_IN_CONDITION)
         }
-        super.visitLoop(loop)
+        loop.acceptChildren(this)
     }
 
     override fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall) = context(context) {
@@ -184,7 +190,7 @@ class MatchersUsageReporterVisitor(
                 reporter.reportOn(it.source, Diagnostics.ILLEGAL_OPERATOR_USAGE, typeOperatorCall.operation.operator)
             }
         }
-        super.visitTypeOperatorCall(typeOperatorCall)
+        typeOperatorCall.acceptChildren(this)
     }
 
     override fun visitEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall) = context(context) {
@@ -197,7 +203,7 @@ class MatchersUsageReporterVisitor(
                 )
             }
         }
-        super.visitEqualityOperatorCall(equalityOperatorCall)
+        equalityOperatorCall.acceptChildren(this)
     }
 
     override fun visitBooleanOperatorExpression(
@@ -208,7 +214,7 @@ class MatchersUsageReporterVisitor(
                 reporter.reportOn(it.source, Diagnostics.ILLEGAL_OPERATOR_USAGE, booleanOperatorExpression.kind.token)
             }
         }
-        super.visitBooleanOperatorExpression(booleanOperatorExpression)
+        booleanOperatorExpression.acceptChildren(this)
     }
 
     override fun visitTryExpression(tryExpression: FirTryExpression) = context(context) {
@@ -223,24 +229,24 @@ class MatchersUsageReporterVisitor(
         if (matchersProcessor.isMatcher(tryExpression.finallyBlock?.lastExpression)) {
             reporter.reportOn(tryExpression.source, Diagnostics.ILLEGAL_TRY_CATCH)
         }
-        super.visitTryExpression(tryExpression)
+        tryExpression.acceptChildren(this)
     }
 
     override fun visitGetClassCall(getClassCall: FirGetClassCall) = context(context) {
         if (matchersProcessor.isMatcher(getClassCall.argument)) {
             reporter.reportOn(getClassCall.argument.source, Diagnostics.ILLEGAL_OPERATOR_USAGE, "::class")
         }
-        super.visitGetClassCall(getClassCall)
+        getClassCall.acceptChildren(this)
     }
 
     override fun visitFunctionCall(functionCall: FirFunctionCall): Unit = context(context) {
         val callee = functionCall.calleeReference as? FirResolvedNamedReference
-            ?: return super.visitFunctionCall(functionCall)
+            ?: return functionCall.acceptChildren(this)
         val symbol = callee.resolvedSymbol as? FirFunctionSymbol<*>
-            ?: return super.visitFunctionCall(functionCall)
+            ?: return functionCall.acceptChildren(this)
         if (symbol.callableId in templatingFunctions) {
             reporter.reportOn(functionCall.source, Diagnostics.ILLEGAL_NESTED_TEMPLATING, symbol.name)
-            return super.visitFunctionCall(functionCall)
+            return functionCall.acceptChildren(this)
         }
         val dispatchReceiver = functionCall.dispatchReceiver
         when {
@@ -258,7 +264,7 @@ class MatchersUsageReporterVisitor(
             }
         }
         currentCallsStack.add(functionCall)
-        super.visitFunctionCall(functionCall)
+        functionCall.acceptChildren(this)
         currentCallsStack.removeLast()
     }
 

mokkery-plugin/src/main/kotlin/dev/mokkery/plugin/ir/IrBuilder.kt

@@ -1,5 +1,6 @@
 package dev.mokkery.plugin.ir
 
+import dev.mokkery.plugin.ir.compat.LOCAL_FUNCTION_FOR_LAMBDA_COMPAT
 import org.jetbrains.kotlin.backend.common.lower.DeclarationIrBuilder
 import org.jetbrains.kotlin.backend.common.lower.irIfThen
 import org.jetbrains.kotlin.backend.common.lower.irNot
@@ -99,7 +100,7 @@ fun IrBuilderWithScope.irLambdaOf(
         this.returnType = returnType
         this.isSuspend = lambdaType.isSuspendFunction()
         visibility = DescriptorVisibilities.LOCAL
-        origin = IrDeclarationOrigin.LOCAL_FUNCTION_FOR_LAMBDA
+        origin = IrDeclarationOrigin.LOCAL_FUNCTION_FOR_LAMBDA_COMPAT
     }.apply {
         val bodyBuilder = DeclarationIrBuilder(context, symbol, startOffset, endOffset)
         params.forEachIndexed { i, it ->

mokkery-plugin/src/main/kotlin/dev/mokkery/plugin/ir/IrClass.kt

@@ -2,6 +2,9 @@ package dev.mokkery.plugin.ir
 
 import dev.mokkery.plugin.ir.annotations.AnnotationFilter
 import dev.mokkery.plugin.ir.annotations.deepApplyAnnotationsFilter
+import dev.mokkery.plugin.ir.compat.DEFAULT_PROPERTY_ACCESSOR_COMPAT
+import dev.mokkery.plugin.ir.compat.DEFINED_COMPAT
+import dev.mokkery.plugin.ir.compat.addBackingFieldCompat
 import org.jetbrains.kotlin.backend.common.lower.DeclarationIrBuilder
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.Modality
@@ -95,7 +98,7 @@ fun IrClass.addOverridingMethod(
         updateFrom(function)
         name = function.name
         modality = Modality.FINAL
-        origin = IrDeclarationOrigin.DEFINED
+        origin = IrDeclarationOrigin.DEFINED_COMPAT
         isFakeOverride = false
     }.apply {
         overriddenSymbols = function.overriddenSymbols + functions.map(IrSimpleFunction::symbol)
@@ -179,7 +182,7 @@ fun IrClass.addOverridingProperty(
         updateFrom(property)
         name = property.name
         modality = Modality.FINAL
-        origin = IrDeclarationOrigin.DEFINED
+        origin = IrDeclarationOrigin.DEFINED_COMPAT
         isFakeOverride = false
     }.apply {
         overriddenSymbols = property.overriddenSymbols + properties.map(IrProperty::symbol)
@@ -219,17 +222,17 @@ fun IrClass.overridePropertyBackingField(context: IrGeneratorContext, property:
         name = property.name
         isVar = property.isVar
         modality = Modality.FINAL
-        origin = IrDeclarationOrigin.DEFINED
+        origin = IrDeclarationOrigin.DEFINED_COMPAT
     }.apply {
         val returnType = property.getter!!.returnType
-        addBackingField {
+        addBackingFieldCompat {
             type = returnType
             visibility = DescriptorVisibilities.PRIVATE
         }
         overriddenSymbols = listOf(property.symbol)
         addGetter {
             this.returnType = returnType
-            origin = IrDeclarationOrigin.DEFAULT_PROPERTY_ACCESSOR
+            origin = IrDeclarationOrigin.DEFAULT_PROPERTY_ACCESSOR_COMPAT
         }.apply {
             parameters = listOf(createDispatchReceiverParameterWithClassParent())
             body = DeclarationIrBuilder(context, symbol).irBlockBody {

mokkery-plugin/src/main/kotlin/dev/mokkery/plugin/ir/compat/IrCompat.kt

@@ -0,0 +1,77 @@
+package dev.mokkery.plugin.ir.compat
+
+import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
+import org.jetbrains.kotlin.ir.builders.declarations.IrFieldBuilder
+import org.jetbrains.kotlin.ir.builders.declarations.buildField
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrField
+import org.jetbrains.kotlin.ir.declarations.IrProperty
+
+fun IrProperty.addBackingFieldCompat(builder: IrFieldBuilder.() -> Unit): IrField {
+    return factory.buildField {
+        name = this@addBackingFieldCompat.name
+        origin = IrDeclarationOrigin.PROPERTY_BACKING_FIELD_COMPAT
+        visibility = DescriptorVisibilities.PRIVATE
+        builder()
+    }.also { field ->
+        this@addBackingFieldCompat.backingField = field
+        field.correspondingPropertySymbol = this@addBackingFieldCompat.symbol
+        field.parent = this@addBackingFieldCompat.parent
+    }
+}
+
+val IrDeclarationOrigin.Companion.LOCAL_FUNCTION_FOR_LAMBDA_COMPAT: IrDeclarationOrigin
+    get() = try {
+        IrDeclarationOrigin.LOCAL_FUNCTION_FOR_LAMBDA
+    } catch (_: NoSuchMethodError) {
+        LOCAL_FUNCTION_FOR_LAMBDA_OLD
+    }
+
+val IrDeclarationOrigin.Companion.PROPERTY_BACKING_FIELD_COMPAT: IrDeclarationOrigin
+    get() = try {
+        IrDeclarationOrigin.PROPERTY_BACKING_FIELD
+    } catch (_: NoSuchMethodError) {
+        PROPERTY_BACKING_FIELD_OLD
+    }
+
+val IrDeclarationOrigin.Companion.DEFAULT_PROPERTY_ACCESSOR_COMPAT: IrDeclarationOrigin
+    get() = try {
+        IrDeclarationOrigin.DEFAULT_PROPERTY_ACCESSOR
+    } catch (_: NoSuchMethodError) {
+        DEFAULT_PROPERTY_ACCESSOR_OLD
+    }
+
+val IrDeclarationOrigin.Companion.DEFINED_COMPAT: IrDeclarationOrigin
+    get() = try {
+        IrDeclarationOrigin.DEFINED
+    } catch (_: NoSuchMethodError) {
+        DEFINED_OLD
+    }
+
+private val DEFINED_OLD: IrDeclarationOrigin by lazy {
+    IrDeclarationOrigin.Companion::class.java
+        .methods
+        .first { it.name == "getDEFINED" }
+        .invoke(IrDeclarationOrigin.Companion) as IrDeclarationOrigin
+}
+
+private val LOCAL_FUNCTION_FOR_LAMBDA_OLD: IrDeclarationOrigin by lazy {
+    IrDeclarationOrigin.Companion::class.java
+        .methods
+        .first { it.name == "getLOCAL_FUNCTION_FOR_LAMBDA" }
+        .invoke(IrDeclarationOrigin.Companion) as IrDeclarationOrigin
+}
+
+private val DEFAULT_PROPERTY_ACCESSOR_OLD: IrDeclarationOrigin by lazy {
+    IrDeclarationOrigin.Companion::class.java
+        .methods
+        .first { it.name == "getDEFAULT_PROPERTY_ACCESSOR" }
+        .invoke(IrDeclarationOrigin.Companion) as IrDeclarationOrigin
+}
+
+private val PROPERTY_BACKING_FIELD_OLD: IrDeclarationOrigin by lazy {
+    IrDeclarationOrigin.Companion::class.java
+        .methods
+        .first { it.name == "getPROPERTY_BACKING_FIELD" }
+        .invoke(IrDeclarationOrigin.Companion) as IrDeclarationOrigin
+}