Merge pull request #80 from lupuuss/release-2.7.1

Release 2.7.1

Author: lupuuss

gradle.properties

@@ -3,6 +3,6 @@ kotlin.code.style=official
 kotlin.suppressGradlePluginWarnings=IncorrectCompileOnlyDependencyWarning
 kotlin.native.ignoreDisabledTargets=true
 org.gradle.jvmargs=-Xmx3g
-version=2.7.0
+version=2.7.1
 org.jetbrains.dokka.experimental.gradle.pluginMode=V2Enabled
 org.jetbrains.dokka.experimental.gradle.pluginMode.noWarn=true

mokkery-plugin/src/main/kotlin/dev/mokkery/plugin/core/Mokkery.kt

@@ -35,14 +35,12 @@ object Mokkery {
         val MokkerySuiteScope by dev_mokkery.klass
 
         val MokkeryCallInterceptor by dev_mokkery_interceptor.klass
-        val MokkeryInstance by dev_mokkery_internal.klass
-        val MokkeryMockInstance by dev_mokkery_internal.klass
+        val MokkeryInstanceScope by dev_mokkery_internal.klass
 
         val CallArgument by dev_mokkery_context.klass
         val SuiteName by dev_mokkery_internal_context.klass
 
         val TemplatingScope by dev_mokkery_internal_calls.klass
-        val MokkeryInstanceLookup by dev_mokkery_internal.klass
         val GlobalMokkeryScope by dev_mokkery_internal.klass
 
         fun mockMany(value: Int): ClassResolver {
@@ -58,25 +56,24 @@ object Mokkery {
     }
 
     object Function {
-        val autofillConstructor by dev_mokkery_internal.function
-        val MokkeryMockInstance by dev_mokkery_internal.function
         val internalEvery by dev_mokkery_internal.function
         val internalEverySuspend by dev_mokkery_internal.function
         val internalVerify by dev_mokkery_internal.function
         val internalVerifySuspend by dev_mokkery_internal.function
         val callIgnoringClassCastException by dev_mokkery_internal.function
-        val createMokkeryBlockingCallScope by dev_mokkery_internal.function
-        val createMokkerySuspendCallScope by dev_mokkery_internal.function
-        val createMokkeryInstanceContext by dev_mokkery_internal.function
-        val MokkeryMockInterceptor by dev_mokkery_internal_interceptor.function
         val TemplatingScope by dev_mokkery_internal_calls.function
-        val invokeMockInstantiationCallbacks by dev_mokkery_internal_context.function
         val MokkerySuiteScope by dev_mokkery.function
+        val MokkeryInstanceScope by dev_mokkery_internal.function
+        val createMokkeryInstanceContext by dev_mokkery_internal.function
+        val invokeMockInstantiationListener by dev_mokkery_internal_context.function
+        val autofillConstructor by dev_mokkery_internal.function
+        val MokkeryMockInterceptor by dev_mokkery_internal_interceptor.function
+        val createMokkeryBlockingCallScope by dev_mokkery_internal.function
+        val createMokkerySuspendCallScope by dev_mokkery_internal.function
     }
 
     object Property {
 
-        val GlobalMokkeryInstanceLookup by dev_mokkery_internal.property
         val mockId by dev_mokkery_internal.property
     }
 

mokkery-plugin/src/main/kotlin/dev/mokkery/plugin/transformers/BuildMockClass.kt

@@ -77,15 +77,15 @@ fun TransformerScope.buildMockClass(
     mokkeryKind: IrMokkeryKind,
     classToMock: IrClass,
 ): IrClass {
-    val mokkeryMockInstanceClass = getClass(Mokkery.Class.MokkeryMockInstance)
+    val instanceScopeClass = getClass(Mokkery.Class.MokkeryInstanceScope)
     val mockedClass = pluginContext
         .irFactory
         .buildClass { name = classToMock.name.createUniqueMockName(mokkeryKind.name) }
     mockedClass.copyTypeParametersFrom(classToMock)
     val typedClassToMock = classToMock.symbol.typeWithParameters(mockedClass.typeParameters)
     mockedClass.superTypes = listOfNotNull(
         typedClassToMock,
-        mokkeryMockInstanceClass.defaultType,
+        instanceScopeClass.defaultType,
         if (classToMock.isInterface) pluginContext.irBuiltIns.anyType else null
     )
     mockedClass.createParameterDeclarations()
@@ -94,7 +94,7 @@ fun TransformerScope.buildMockClass(
         transformer = this,
         typeName = classToMock.kotlinFqName.asString(),
         mokkeryKind = mokkeryKind,
-        mokkeryInstanceClass = mokkeryMockInstanceClass,
+        scopeInstanceClass = instanceScopeClass,
         classesToIntercept = listOf(classToMock),
     )
     val spyDelegateField = mockedClass.getField(Mokkery.Fields.SpyDelegate)
@@ -112,7 +112,7 @@ fun TransformerScope.buildMockClass(
 
 fun TransformerScope.buildManyMockClass(classesToMock: List<IrClass>): IrClass {
     val manyMocksMarkerClass = getClass(Mokkery.Class.mockMany(classesToMock.size))
-    val mokkeryMockInstanceClass = getClass(Mokkery.Class.MokkeryMockInstance)
+    val mokkeryInstanceClass = getClass(Mokkery.Class.MokkeryInstanceScope)
     val mockedClass = pluginContext.irFactory
         .buildClass { name = manyMocksMarkerClass.kotlinFqName.createUniqueManyMockName() }
     classesToMock.forEach(mockedClass::copyTypeParametersFrom)
@@ -122,13 +122,13 @@ fun TransformerScope.buildManyMockClass(classesToMock: List<IrClass>): IrClass {
     val mockedTypes = classesToMock.typeWith(parameterMap)
     val manyMocksMarkerType = manyMocksMarkerClass.symbol.typeWith(mockedTypes)
     mockedClass.superTypes = mockedTypes + listOfNotNull(
-        mokkeryMockInstanceClass.defaultType,
+        mokkeryInstanceClass.defaultType,
         if (classesToMock.all(IrClass::isInterface)) pluginContext.irBuiltIns.anyType else null,
         manyMocksMarkerType
     )
     mockedClass.addMockClassConstructor(
         transformer = this,
-        mokkeryInstanceClass = mokkeryMockInstanceClass,
+        scopeInstanceClass = mokkeryInstanceClass,
         mokkeryKind = IrMokkeryKind.Mock,
         typeName = mockManyTypeName(manyMocksMarkerClass, classesToMock),
         classesToIntercept = classesToMock,
@@ -181,7 +181,7 @@ private fun IrBlockBodyBuilder.mockBody(
 
 private fun IrClass.addMockClassConstructor(
     transformer: TransformerScope,
-    mokkeryInstanceClass: IrClass,
+    scopeInstanceClass: IrClass,
     mokkeryKind: IrMokkeryKind,
     typeName: String,
     classesToIntercept: List<IrClass>,
@@ -191,9 +191,9 @@ private fun IrClass.addMockClassConstructor(
     val mokkeryScopeClass = transformer.getClass(Mokkery.Class.MokkeryScope)
     val mockModeClass = transformer.getClass(Mokkery.Class.MockMode)
     val mokkeryKindClass = transformer.getClass(Mokkery.Class.MokkeryKind)
-    val invokeInstantiationCallbacksFun = transformer.getFunction(Mokkery.Function.invokeMockInstantiationCallbacks)
-    val interceptor = overridePropertyBackingField(context, mokkeryInstanceClass.getProperty("mokkeryInterceptor"))
-    val contextProperty = overridePropertyBackingField(context, mokkeryInstanceClass.getProperty("mokkeryContext"))
+    val invokeInstantiationCallbacksFun = transformer.getFunction(Mokkery.Function.invokeMockInstantiationListener)
+    val interceptor = overridePropertyBackingField(context, scopeInstanceClass.getProperty("mokkeryInterceptor"))
+    val contextProperty = overridePropertyBackingField(context, scopeInstanceClass.getProperty("mokkeryContext"))
     addConstructor {
         isPrimary = true
     }.apply {
@@ -250,6 +250,7 @@ private fun IrClass.addMockClassConstructor(
             }
             +irCall(invokeInstantiationCallbacksFun) {
                 extensionReceiver = irGet(thisReceiver!!)
+                putValueArgument(0, irGet(thisReceiver!!))
             }
             +irInvokeIfNotNull(irGet(valueParameters[2]), false, irGet(thisReceiver!!))
         }

mokkery-plugin/src/main/kotlin/dev/mokkery/plugin/transformers/BuildMockJsFunction.kt

@@ -6,7 +6,6 @@ import dev.mokkery.plugin.core.TransformerScope
 import dev.mokkery.plugin.core.declarationIrBuilder
 import dev.mokkery.plugin.core.getClass
 import dev.mokkery.plugin.core.getFunction
-import dev.mokkery.plugin.core.getProperty
 import dev.mokkery.plugin.core.mockMode
 import dev.mokkery.plugin.ir.defaultTypeErased
 import dev.mokkery.plugin.ir.indexIfParameterOrNull
@@ -71,9 +70,9 @@ fun TransformerScope.buildMockJsFunction(
                 +irReturn(irInterceptCall(transformer, irGet(instanceVar), it, mapTypeToClass, irSpyCall))
             }
             val lambdaVar = createTmpVariable(lambda)
-            +irCallRegisterInstance(transformer, irGet(instanceVar), irGet(lambdaVar))
-            +irCall(transformer.getFunction(Mokkery.Function.invokeMockInstantiationCallbacks)) {
+            +irCall(transformer.getFunction(Mokkery.Function.invokeMockInstantiationListener)) {
                 this.extensionReceiver = irGet(instanceVar)
+                putValueArgument(0, irGet(lambdaVar))
             }
             val block = expression.valueArguments.getOrNull(1)
             if (block != null) {
@@ -106,8 +105,8 @@ private fun IrBuilderWithScope.irCallMokkeryMockInstance(
     modeArg: IrExpression,
     kind: IrMokkeryKind,
 ): IrExpression {
-    val mokkeryMockInstanceFun = transformer.getFunction(Mokkery.Function.MokkeryMockInstance)
-    return irCall(mokkeryMockInstanceFun) {
+    val instanceScopeFun = transformer.getFunction(Mokkery.Function.MokkeryInstanceScope)
+    return irCall(instanceScopeFun) {
         putValueArgument(0, parentScope)
         putValueArgument(1, modeArg)
         putValueArgument(2, irMokkeryKindValue(transformer.getClass(Mokkery.Class.MokkeryKind), kind))
@@ -116,22 +115,6 @@ private fun IrBuilderWithScope.irCallMokkeryMockInstance(
     }
 }
 
-private fun IrBuilderWithScope.irCallRegisterInstance(
-    transformer: TransformerScope,
-    mokkeryInstance: IrExpression,
-    obj: IrExpression
-): IrCall {
-    val instanceLookupCall = irCall(transformer.getProperty(Mokkery.Property.GlobalMokkeryInstanceLookup).getter!!)
-    val lookUpClass = transformer.getClass(Mokkery.Class.MokkeryInstanceLookup)
-    val registerCall = irCall(lookUpClass.getSimpleFunction("register")!!) {
-        dispatchReceiver = instanceLookupCall
-        putValueArgument(0, obj)
-        putValueArgument(1, mokkeryInstance)
-    }
-    return registerCall
-}
-
-
 private fun IrBlockBodyBuilder.irLambdaInvokeSpy(
     transformer: TransformerScope,
     delegateLambda: IrExpression,

mokkery-plugin/src/main/kotlin/dev/mokkery/plugin/transformers/IrInterceptCall.kt

@@ -80,12 +80,12 @@ fun IrBlockBodyBuilder.irInterceptCall(
     irCallSpyLambda: IrExpression? = null
 ): IrCall {
     val interceptorClass = transformer.getClass(Mokkery.Class.MokkeryCallInterceptor).symbol
-    val mokkeryInstanceClass = transformer.getClass(Mokkery.Class.MokkeryInstance)
+    val instanceScopeClass = transformer.getClass(Mokkery.Class.MokkeryInstanceScope)
     val interceptFun = interceptorClass
         .functions
         .first { it.owner.name.asString() == "intercept" && it.owner.isSuspend == function.isSuspend }
     return irCall(interceptFun) {
-        dispatchReceiver = mokkeryInstanceClass
+        dispatchReceiver = instanceScopeClass
             .getPropertyGetter("mokkeryInterceptor")!!
             .let(::irCall)
             .apply { dispatchReceiver = mokkeryInstance }

mokkery-runtime/src/commonMain/kotlin/dev/mokkery/MokkerySuiteScope.kt

@@ -5,12 +5,17 @@ import dev.mokkery.context.require
 import dev.mokkery.internal.GlobalMokkeryScope
 import dev.mokkery.internal.MokkerySuiteScopeNotImplementedException
 import dev.mokkery.internal.context.MocksRegistry
+import dev.mokkery.internal.utils.instances
 
 /**
  * Returns all mocks from this [MokkerySuiteScope].
  */
-public val MokkerySuiteScope.mocks: Set<Any>
-    get() = mokkeryContext.require(MocksRegistry).mocks
+public val MokkerySuiteScope.mocks: List<Any>
+    get() = mokkeryContext
+        .require(MocksRegistry)
+        .mocks
+        .instances
+        .toList()
 
 /**
  * A scope for a test suite that uses Mokkery mocks. It enables automation and strict exhaustiveness checks.

mokkery-runtime/src/commonMain/kotlin/dev/mokkery/Reset.kt

@@ -1,18 +1,17 @@
 package dev.mokkery
 
 import dev.mokkery.internal.GlobalMokkeryScope
-import dev.mokkery.internal.ObjectNotMockedException
-import dev.mokkery.internal.context.resolveMockInstance
+import dev.mokkery.internal.context.resolveScope
 import dev.mokkery.internal.context.tools
-import dev.mokkery.internal.interceptor
+import dev.mokkery.internal.mokkeryMockInterceptor
 
 /**
  * Removes all answers configured for given [mocks].
  */
 public fun resetAnswers(vararg mocks: Any) {
     mocks.forEach {
-        val instance = GlobalMokkeryScope.tools.resolveMockInstance(it) ?: throw ObjectNotMockedException(it)
-        instance.interceptor.answering.reset()
+        val instanceScope = GlobalMokkeryScope.tools.resolveScope(it)
+        instanceScope.mokkeryMockInterceptor.answering.reset()
     }
 }
 
@@ -21,7 +20,7 @@ public fun resetAnswers(vararg mocks: Any) {
  */
 public fun resetCalls(vararg mocks: Any) {
     mocks.forEach {
-        val instance = GlobalMokkeryScope.tools.resolveMockInstance(it) ?: throw ObjectNotMockedException(it)
-        instance.interceptor.callTracing.reset()
+        val instanceScope = GlobalMokkeryScope.tools.resolveScope(it)
+        instanceScope.mokkeryMockInterceptor.callTracing.reset()
     }
 }

mokkery-runtime/src/commonMain/kotlin/dev/mokkery/Verify.kt

@@ -2,13 +2,14 @@
 
 package dev.mokkery
 
+import dev.mokkery.context.require
+import dev.mokkery.internal.GlobalMokkeryScope
 import dev.mokkery.internal.context.MocksRegistry
 import dev.mokkery.internal.MokkeryPluginNotAppliedException
-import dev.mokkery.internal.ObjectNotMockedException
 import dev.mokkery.internal.calls.CallTrace
-import dev.mokkery.internal.context.resolveMockInstance
+import dev.mokkery.internal.context.resolveScope
 import dev.mokkery.internal.context.tools
-import dev.mokkery.internal.interceptor
+import dev.mokkery.internal.mokkeryMockInterceptor
 import dev.mokkery.internal.names.createGroupMockReceiverShortener
 import dev.mokkery.internal.render.PointListRenderer
 import dev.mokkery.internal.utils.failAssertion
@@ -66,28 +67,32 @@ public fun MokkerySuiteScope.verifySuspend(
  * Asserts that all given [mocks] have all their registered calls verified with [verify] or [verifySuspend].
  */
 public fun verifyNoMoreCalls(vararg mocks: Any) {
-    MokkerySuiteScope(MocksRegistry(mocks = mocks.toSet())).verifyNoMoreCalls()
+    val tools = GlobalMokkeryScope.tools
+    val instances = mocks.map(tools::resolveScope)
+    MokkerySuiteScope(MocksRegistry(mocks = instances)).verifyNoMoreCalls()
 }
 
 /**
  * Asserts that all mocks from given [MokkerySuiteScope] have no unverified calls.
  */
 public fun MokkerySuiteScope.verifyNoMoreCalls() {
-    val tools = this.tools
-    mocks.forEach { mock ->
-        val tracing = mock
-            .let { tools.resolveMockInstance(it) }
-            ?.interceptor
-            ?.callTracing ?: throw ObjectNotMockedException(mock)
-        if (tracing.unverified.isNotEmpty()) {
-            failAssertion {
-                val renderer = PointListRenderer<CallTrace>()
-                val shortener = tools.createGroupMockReceiverShortener()
-                shortener.prepare(tracing.unverified, emptyList())
-                val unverifiedCalls = shortener.shortenTraces(tracing.unverified)
-                appendLine("Unverified calls for $mock:")
-                append(renderer.render(unverifiedCalls))
+    mokkeryContext
+        .require(MocksRegistry)
+        .mocks
+        .scopes
+        .forEach { mock ->
+            val tracing = mock
+                .mokkeryMockInterceptor
+                .callTracing
+            if (tracing.unverified.isNotEmpty()) {
+                failAssertion {
+                    val renderer = PointListRenderer<CallTrace>()
+                    val shortener = tools.createGroupMockReceiverShortener()
+                    shortener.prepare(tracing.unverified, emptyList())
+                    val unverifiedCalls = shortener.shortenTraces(tracing.unverified)
+                    appendLine("Unverified calls for $mock:")
+                    append(renderer.render(unverifiedCalls))
+                }
             }
         }
-    }
 }

mokkery-runtime/src/commonMain/kotlin/dev/mokkery/debug/Debug.kt

@@ -2,26 +2,26 @@ package dev.mokkery.debug
 
 import dev.mokkery.answering.Answer
 import dev.mokkery.internal.GlobalMokkeryScope
-import dev.mokkery.internal.MokkeryMockInstance
+import dev.mokkery.internal.MokkeryInstanceScope
 import dev.mokkery.internal.context.currentMockContext
-import dev.mokkery.internal.context.resolveMockInstance
+import dev.mokkery.internal.context.resolveScopeOrNull
 import dev.mokkery.internal.context.tools
-import dev.mokkery.internal.id
-import dev.mokkery.internal.interceptor
 import dev.mokkery.internal.interceptor.AnsweringInterceptor
 import dev.mokkery.internal.interceptor.CallTracingInterceptor
 import dev.mokkery.internal.interceptor.MokkeryKind
+import dev.mokkery.internal.mockId
+import dev.mokkery.internal.mokkeryMockInterceptor
 
 /**
  * Returns json-like structure of [obj] details (tracked calls, configured answers etc.).
  */
 public fun mokkeryDebugString(obj: Any): String {
-    return when (val instance = GlobalMokkeryScope.tools.resolveMockInstance(obj)) {
-        is MokkeryMockInstance -> when (instance.currentMockContext.kind) {
-            MokkeryKind.Spy -> mokkeryDebugSpy(instance)
-            MokkeryKind.Mock ->  mokkeryDebugMock(instance)
+    return when (val scope = GlobalMokkeryScope.tools.resolveScopeOrNull(obj)) {
+        null -> "Not a mock/spy -> $obj"
+        else -> when (scope.currentMockContext.kind) {
+            MokkeryKind.Spy -> mokkeryDebugSpy(scope)
+            MokkeryKind.Mock ->  mokkeryDebugMock(scope)
         }
-        else -> "Not a mock/spy -> $obj"
     }
 }
 
@@ -32,23 +32,23 @@ public fun printMokkeryDebug(obj: Any) {
     println(mokkeryDebugString(obj))
 }
 
-private fun mokkeryDebugMock(instance: MokkeryMockInstance): String {
+private fun mokkeryDebugMock(instance: MokkeryInstanceScope): String {
     return buildHierarchicalString {
         section("mock") {
-            value("id", instance.id)
+            value("id", instance.mockId)
             value("mode", instance.currentMockContext.mode.name)
-            answersSection(instance.interceptor.answering)
-            callsSection(instance.interceptor.callTracing)
+            answersSection(instance.mokkeryMockInterceptor.answering)
+            callsSection(instance.mokkeryMockInterceptor.callTracing)
         }
     }
 }
 
-private fun mokkeryDebugSpy(instance: MokkeryMockInstance): String {
+private fun mokkeryDebugSpy(instance: MokkeryInstanceScope): String {
     return buildHierarchicalString {
         section("spy") {
-            value("id", instance.id)
-            answersSection(instance.interceptor.answering)
-            callsSection(instance.interceptor.callTracing)
+            value("id", instance.mockId)
+            answersSection(instance.mokkeryMockInterceptor.answering)
+            callsSection(instance.mokkeryMockInterceptor.callTracing)
         }
     }
 }