Merge pull request #123 from lupuuss/release-3.1.1

lupuuss · web-flow · commit f6e24dc20b0c · 2025-12-18T00:30:04.000+01:00
Release 3.1.1
diff --git a/gradle.properties b/gradle.properties
@@ -3,6 +3,7 @@ kotlin.code.style=official
 kotlin.suppressGradlePluginWarnings=IncorrectCompileOnlyDependencyWarning
 kotlin.native.ignoreDisabledTargets=true
 org.gradle.jvmargs=-Xmx3g
-version=3.1.0
+version=3.1.1
 org.jetbrains.dokka.experimental.gradle.pluginMode=V2Enabled
 org.jetbrains.dokka.experimental.gradle.pluginMode.noWarn=true
+org.gradle.parallel=true
diff --git a/mokkery-plugin/src/main/kotlin/dev/mokkery/plugin/diagnostics/MocksCreationChecker.kt b/mokkery-plugin/src/main/kotlin/dev/mokkery/plugin/diagnostics/MocksCreationChecker.kt
@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirFunctionCallChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.isSubtypeOfThrowable
 import org.jetbrains.kotlin.fir.declarations.constructors
+import org.jetbrains.kotlin.fir.declarations.utils.isEnumClass
 import org.jetbrains.kotlin.fir.declarations.utils.isFinal
 import org.jetbrains.kotlin.fir.declarations.utils.isInline
 import org.jetbrains.kotlin.fir.declarations.utils.isInlineOrValue
@@ -297,7 +298,6 @@ class MocksCreationChecker(
         val cls = type
             .toRegularClassSymbol()
             ?: return listOf(type to StubError.NoAccessibleConstructors)
-        if (cls.isInlineOrValue) return emptyList()
         val constructors = cls
             .constructors(context.session)
             .filter { it.isAccessible() }
@@ -339,7 +339,8 @@ class MocksCreationChecker(
                 || isSomeFunctionType(context.session)
                 || toRegularClassSymbol()?.let { cls ->
                     val fqName = cls.packageFqName()
-                    cls.isInterface()
+                    cls.isRegularInterface()
+                            || cls.isEnumClass
                             || cls.isInlineClass()
                             || fqName.isSubpackageOf(Kotlin.kotlin_collections)
                             || fqName.isSubpackageOf(Kotlin.kotlin_ranges)
@@ -349,7 +350,7 @@ class MocksCreationChecker(
 
     }
 
-    private fun FirRegularClassSymbol?.isInterface(): Boolean = this?.classKind == ClassKind.INTERFACE && !this.isSealed
+    private fun FirRegularClassSymbol?.isRegularInterface(): Boolean = this?.classKind == ClassKind.INTERFACE && !this.isSealed
 
     private fun FirRegularClassSymbol?.isInlineClass(): Boolean = this?.isInlineOrValue == true
 
diff --git a/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/Verify.kt b/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/Verify.kt
@@ -79,8 +79,7 @@ public fun MokkerySuiteScope.verifyNoMoreCalls() {
         sessions.forEach { (id, session) ->
             if (session.unverified.isNotEmpty()) {
                 val message = NoMoreCallsErrorRenderer
-                    .factory(tools.namesShortener, collection)
-                    .create()
+                    .lazy(tools.namesShortener, collection)
                     .render(id to unverified)
                 throw AssertionError(message)
             }
diff --git a/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/render/RendererFactory.kt b/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/render/RendererFactory.kt
diff --git a/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/ExhaustiveOrderVerifier.kt b/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/ExhaustiveOrderVerifier.kt
@@ -2,7 +2,7 @@ package dev.mokkery.internal.verify
 
 import dev.mokkery.internal.matcher.CallMatcher
 import dev.mokkery.internal.matcher.isNotMatching
-import dev.mokkery.internal.render.RendererFactory
+import dev.mokkery.internal.render.Renderer
 import dev.mokkery.internal.templating.CallTemplate
 import dev.mokkery.internal.tracing.CallTrace
 import dev.mokkery.internal.verify.results.TemplateMatchingResult
@@ -11,7 +11,7 @@ import dev.mokkery.internal.verify.results.TemplateMatchingResultsComposer
 internal class ExhaustiveOrderVerifier(
     private val callMatcher: CallMatcher,
     private val resultsComposer: TemplateMatchingResultsComposer,
-    private val errorRendererFactory: RendererFactory<Error>,
+    private val errorRenderer: Renderer<Error>,
 ) : Verifier {
 
     override fun verify(callTraces: List<CallTrace>, callTemplates: List<CallTemplate>): List<CallTrace> {
@@ -25,7 +25,7 @@ internal class ExhaustiveOrderVerifier(
 
     private fun fail(callTraces: List<CallTrace>, callTemplates: List<CallTemplate>): Nothing {
         val error = Error(resultsComposer.compose(callTraces, callTemplates))
-        throw AssertionError(errorRendererFactory.create().render(error))
+        throw AssertionError(errorRenderer.render(error))
     }
 
 
diff --git a/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/ExhaustiveSoftVerifier.kt b/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/ExhaustiveSoftVerifier.kt
@@ -2,14 +2,14 @@ package dev.mokkery.internal.verify
 
 import dev.mokkery.internal.matcher.CallMatcher
 import dev.mokkery.internal.matcher.isMatching
-import dev.mokkery.internal.render.RendererFactory
+import dev.mokkery.internal.render.Renderer
 import dev.mokkery.internal.templating.CallTemplate
 import dev.mokkery.internal.tracing.CallTrace
 import dev.mokkery.internal.verify.results.TemplateGroupedMatchingResults
 
 internal class ExhaustiveSoftVerifier(
     private val callMatcher: CallMatcher,
-    private val errorRendererFactory: RendererFactory<Error>
+    private val errorRenderer: Renderer<Error>
 ) : Verifier {
 
     override fun verify(callTraces: List<CallTrace>, callTemplates: List<CallTemplate>): List<CallTrace> {
@@ -27,7 +27,7 @@ internal class ExhaustiveSoftVerifier(
         return callTraces
     }
 
-    private fun fail(error: Error): Nothing = throw AssertionError(errorRendererFactory.create().render(error))
+    private fun fail(error: Error): Nothing = throw AssertionError(errorRenderer.render(error))
 
     sealed class Error {
         data class NoMatch(val templateMatchingResults: TemplateGroupedMatchingResults) : Error()
diff --git a/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/NotVerifier.kt b/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/NotVerifier.kt
@@ -2,14 +2,14 @@ package dev.mokkery.internal.verify
 
 import dev.mokkery.internal.matcher.CallMatcher
 import dev.mokkery.internal.matcher.isMatching
-import dev.mokkery.internal.render.RendererFactory
+import dev.mokkery.internal.render.Renderer
 import dev.mokkery.internal.templating.CallTemplate
 import dev.mokkery.internal.tracing.CallTrace
 
 internal class NotVerifier(
     private val callMatcher: CallMatcher,
-    private val errorRendererFactory: RendererFactory<Error>,
-    ) : Verifier {
+    private val errorRenderer: Renderer<Error>
+) : Verifier {
 
     override fun verify(
         callTraces: List<CallTrace>,
@@ -20,7 +20,7 @@ internal class NotVerifier(
                 if (callMatcher.match(trace, template).isMatching) {
                     val matching = callTraces.filter { callMatcher.match(it, template).isMatching }
                     val error = Error(template, matching)
-                    throw AssertionError(errorRendererFactory.create().render(error))
+                    throw AssertionError(errorRenderer.render(error))
                 }
             }
         }
diff --git a/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/OrderVerifier.kt b/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/OrderVerifier.kt
@@ -2,7 +2,7 @@ package dev.mokkery.internal.verify
 
 import dev.mokkery.internal.matcher.CallMatcher
 import dev.mokkery.internal.matcher.isMatching
-import dev.mokkery.internal.render.RendererFactory
+import dev.mokkery.internal.render.Renderer
 import dev.mokkery.internal.templating.CallTemplate
 import dev.mokkery.internal.tracing.CallTrace
 import dev.mokkery.internal.verify.results.TemplateMatchingResult
@@ -11,7 +11,7 @@ import dev.mokkery.internal.verify.results.TemplateMatchingResultsComposer
 internal class OrderVerifier(
     private val callMatcher: CallMatcher,
     private val resultsComposer: TemplateMatchingResultsComposer,
-    private val errorRendererFactory: RendererFactory<Error>,
+    private val errorRenderer: Renderer<Error>,
 ) : Verifier {
 
     override fun verify(callTraces: List<CallTrace>, callTemplates: List<CallTemplate>): List<CallTrace> {
@@ -25,7 +25,7 @@ internal class OrderVerifier(
                     failedIndex = templateIndex,
                     results = resultsComposer.compose(callTraces, callTemplates)
                 )
-                throw AssertionError(errorRendererFactory.create().render(error))
+                throw AssertionError(errorRenderer.render(error))
             }
             verifiedTraces.add(currentTraces[matchingTraceIndex])
             currentTraces = currentTraces.subList(matchingTraceIndex + 1, currentTraces.size)
diff --git a/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/SoftVerifier.kt b/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/SoftVerifier.kt
@@ -2,7 +2,7 @@ package dev.mokkery.internal.verify
 
 import dev.mokkery.internal.matcher.CallMatcher
 import dev.mokkery.internal.matcher.isMatching
-import dev.mokkery.internal.render.RendererFactory
+import dev.mokkery.internal.render.Renderer
 import dev.mokkery.internal.templating.CallTemplate
 import dev.mokkery.internal.tracing.CallTrace
 import dev.mokkery.internal.verify.results.TemplateGroupedMatchingResults
@@ -11,7 +11,7 @@ internal class SoftVerifier(
     private val atLeast: Int,
     private val atMost: Int,
     private val callMatcher: CallMatcher,
-    private val errorRendererFactory: RendererFactory<Error>,
+    private val errorRenderer: Renderer<Error>,
 ) : Verifier {
 
     override fun verify(
@@ -28,7 +28,7 @@ internal class SoftVerifier(
                     calls = callTraces.groupBy { callMatcher.match(it, template) }
                 )
             )
-            throw AssertionError(errorRendererFactory.create().render(error))
+            throw AssertionError(errorRenderer.render(error))
         }
         matching
     }
diff --git a/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/VerifierFactory.kt b/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/VerifierFactory.kt
@@ -36,26 +36,26 @@ private class VerifierFactoryImpl(
             OrderVerifyMode -> OrderVerifier(
                 callMatcher = callMatcher,
                 resultsComposer = TemplateMatchingResultsComposer(callMatcher),
-                errorRendererFactory = OrderVerifierErrorRenderer.factory(namesShortener, collection)
+                errorRenderer = OrderVerifierErrorRenderer.lazy(namesShortener, collection)
             )
             ExhaustiveOrderVerifyMode -> ExhaustiveOrderVerifier(
                 resultsComposer = TemplateMatchingResultsComposer(callMatcher),
                 callMatcher = callMatcher,
-                errorRendererFactory = ExhaustiveOrderVerifierErrorRenderer.factory(namesShortener, collection)
+                errorRenderer = ExhaustiveOrderVerifierErrorRenderer.lazy(namesShortener, collection)
             )
             ExhaustiveSoftVerifyMode -> ExhaustiveSoftVerifier(
                 callMatcher = callMatcher,
-                errorRendererFactory = ExhaustiveSoftVerifierErrorRenderer.factory(namesShortener, collection)
+                errorRenderer = ExhaustiveSoftVerifierErrorRenderer.lazy(namesShortener, collection)
             )
             NotVerifyMode -> NotVerifier(
                 callMatcher = callMatcher,
-                errorRendererFactory = NotVerifierErrorRenderer.factory(namesShortener, collection)
+                errorRenderer = NotVerifierErrorRenderer.lazy(namesShortener, collection)
             )
             is SoftVerifyMode -> SoftVerifier(
                 atLeast = mode.atLeast,
                 atMost = mode.atMost,
                 callMatcher = callMatcher,
-                errorRendererFactory = SoftVerifierErrorRenderer.factory(namesShortener, collection)
+                errorRenderer = SoftVerifierErrorRenderer.lazy(namesShortener, collection)
             )
         }
     }
diff --git a/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/render/ExhaustiveOrderVerifierErrorRenderer.kt b/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/render/ExhaustiveOrderVerifierErrorRenderer.kt
@@ -17,10 +17,10 @@ internal class ExhaustiveOrderVerifierErrorRenderer(
 
     companion object {
 
-        fun factory(
+        fun lazy(
             nameShortener: NameShortener,
             collection: MokkeryCollection
-        ) = verifyRendererFactory(nameShortener, collection) {
+        ) = lazyVerifyRenderer(nameShortener, collection) {
             ExhaustiveOrderVerifierErrorRenderer(matchingResultsRenderer = templateMatchingResultsRenderer)
         }
     }
diff --git a/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/render/ExhaustiveSoftVerifierErrorRenderer.kt b/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/render/ExhaustiveSoftVerifierErrorRenderer.kt
@@ -28,10 +28,10 @@ internal class ExhaustiveSoftVerifierErrorRenderer(
 
     companion object {
 
-        fun factory(
+        fun lazy(
             nameShortener: NameShortener,
             collection: MokkeryCollection
-        ) = verifyRendererFactory(nameShortener, collection) {
+        ) = lazyVerifyRenderer(nameShortener, collection) {
             ExhaustiveSoftVerifierErrorRenderer(
                 templateRenderer = callTemplateAliasRenderer,
                 matchingResultsRenderer = templateGroupedMatchingResultsRenderer,
diff --git a/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/render/NoMoreCallsErrorRenderer.kt b/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/render/NoMoreCallsErrorRenderer.kt
@@ -19,10 +19,10 @@ internal class NoMoreCallsErrorRenderer(
 
     companion object {
 
-        fun factory(
+        fun lazy(
             nameShortener: NameShortener,
             collection: MokkeryCollection
-        ) = verifyRendererFactory(nameShortener, collection) {
+        ) = lazyVerifyRenderer(nameShortener, collection) {
             NoMoreCallsErrorRenderer(
                 instanceIdRenderer = instanceIdAliasRenderer,
                 callsListRenderer = pointsRenderer(item = callTraceAliasRenderer)
diff --git a/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/render/NotVerifierErrorRenderer.kt b/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/render/NotVerifierErrorRenderer.kt
@@ -20,10 +20,10 @@ internal class NotVerifierErrorRenderer(
 
     companion object {
 
-        fun factory(
+        fun lazy(
             nameShortener: NameShortener,
             collection: MokkeryCollection
-        ) = verifyRendererFactory(nameShortener, collection) {
+        ) = lazyVerifyRenderer(nameShortener, collection) {
             NotVerifierErrorRenderer(
                 templateRenderer = callTemplateAliasRenderer,
                 traceListRenderer = Renderers.points(item = callTraceAliasRenderer)
diff --git a/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/render/OrderVerifierErrorRenderer.kt b/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/render/OrderVerifierErrorRenderer.kt
@@ -19,10 +19,11 @@ internal class OrderVerifierErrorRenderer(
     }
 
     companion object {
-        fun factory(
+
+        fun lazy(
             nameShortener: NameShortener,
             collection: MokkeryCollection
-        ) = verifyRendererFactory(nameShortener, collection) {
+        ) = lazyVerifyRenderer(nameShortener, collection) {
             OrderVerifierErrorRenderer(
                 templateRenderer = callTemplateAliasRenderer,
                 matchingResultsRenderer = templateMatchingResultsRenderer
diff --git a/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/render/SoftVerifierErrorRenderer.kt b/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/render/SoftVerifierErrorRenderer.kt
@@ -37,10 +37,10 @@ internal class SoftVerifierErrorRenderer(
 
     companion object {
 
-        fun factory(
+        fun lazy(
             nameShortener: NameShortener,
             collection: MokkeryCollection
-        ) = verifyRendererFactory(nameShortener, collection) {
+        ) = lazyVerifyRenderer(nameShortener, collection) {
             SoftVerifierErrorRenderer(
                 templateRenderer = callTemplateAliasRenderer,
                 matchingResultsRenderer = templateGroupedMatchingResultsRenderer
diff --git a/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/render/VerifyRendererFactory.kt b/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/internal/verify/render/VerifyRendererFactory.kt
@@ -7,14 +7,13 @@ import dev.mokkery.internal.names.AliasMokkeryCollection
 import dev.mokkery.internal.names.NameShortener
 import dev.mokkery.internal.names.withShorterNames
 import dev.mokkery.internal.render.Renderer
-import dev.mokkery.internal.render.RendererFactory
 import dev.mokkery.internal.render.Renderers
 import dev.mokkery.internal.templating.CallTemplate
 import dev.mokkery.internal.tracing.CallTrace
 import dev.mokkery.internal.verify.results.TemplateGroupedMatchingResults
 import dev.mokkery.internal.verify.results.TemplateMatchingResult
 
-internal interface VerifyRendererFactoryScope {
+internal interface LazyVerifyRendererScope {
 
     val callTraceAliasRenderer: Renderer<CallTrace>
 
@@ -29,26 +28,25 @@ internal interface VerifyRendererFactoryScope {
     fun <T> pointsRenderer(item: Renderer<T>): Renderer<List<T>>
 }
 
-internal inline fun <T> verifyRendererFactory(
+internal inline fun <T> lazyVerifyRenderer(
     nameShortener: NameShortener,
     collection: MokkeryCollection,
-    crossinline block: VerifyRendererFactoryScope.() -> Renderer<T>
-): RendererFactory<T> = RendererFactory {
-    block(VerifyRendererFactoryScope(nameShortener, collection))
+    crossinline block: LazyVerifyRendererScope.() -> Renderer<T>
+): Renderer<T> = Renderer {
+    block(LazyVerifyRendererScope(nameShortener, collection))
+        .render(it)
 }
 
 
-internal fun VerifyRendererFactoryScope(
+internal fun LazyVerifyRendererScope(
     nameShortener: NameShortener,
     collection: MokkeryCollection,
-): VerifyRendererFactoryScope {
-    return VerifyRendererFactoryScopeImpl(nameShortener, collection)
-}
+): LazyVerifyRendererScope = LazyVerifyRendererScopeImpl(nameShortener, collection)
 
-private class VerifyRendererFactoryScopeImpl(
+private class LazyVerifyRendererScopeImpl(
     private val nameShortener: NameShortener,
     private val collection: MokkeryCollection,
-) : VerifyRendererFactoryScope {
+) : LazyVerifyRendererScope {
 
     // this way of lazy initialization is more performant than lazy delegate
 
diff --git a/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/matcher/logical/LogicalMatchers.kt b/mokkery-runtime/src/commonMain/kotlin/dev/mokkery/matcher/logical/LogicalMatchers.kt
@@ -56,7 +56,7 @@ public object LogicalMatchers {
         public val matcher: ArgMatcher<T> get() = matchers[0]
 
         @Deprecated(
-            "This field should not be used anymore. Now, `Not` matcher might contain more than one matcher.",
+            "This constructor should not be used anymore. Now, `Not` matcher might contain more than one matcher.",
             ReplaceWith("Not(listOf<_>(matcher))")
         )
         public constructor(matcher: ArgMatcher<T>) : this(listOf(matcher))
diff --git a/mokkery-runtime/src/commonTest/kotlin/dev/mokkery/internal/verify/ExhaustiveOrderVerifierTest.kt b/mokkery-runtime/src/commonTest/kotlin/dev/mokkery/internal/verify/ExhaustiveOrderVerifierTest.kt
@@ -33,7 +33,7 @@ class ExhaustiveOrderVerifierTest {
     private val verifier = ExhaustiveOrderVerifier(
         callMatcher = callMatcher,
         resultsComposer = resultsTestComposer,
-        errorRendererFactory = ::testRenderer
+        errorRenderer = testRenderer
     )
 
     @Test
diff --git a/mokkery-runtime/src/commonTest/kotlin/dev/mokkery/internal/verify/ExhaustiveSoftVerifierTest.kt b/mokkery-runtime/src/commonTest/kotlin/dev/mokkery/internal/verify/ExhaustiveSoftVerifierTest.kt
@@ -25,7 +25,7 @@ class ExhaustiveSoftVerifierTest {
         }
     }
     private val testRenderer = TestRenderer<ExhaustiveSoftVerifier.Error> { "RENDERED_ERROR" }
-    private val verifier = ExhaustiveSoftVerifier(callMatcher = callMatcher, errorRendererFactory = ::testRenderer)
+    private val verifier = ExhaustiveSoftVerifier(callMatcher = callMatcher, errorRenderer = testRenderer)
 
     @Test
     fun testSuccessWhenAllCallsMatch() {
diff --git a/mokkery-runtime/src/commonTest/kotlin/dev/mokkery/internal/verify/NotVerifierTest.kt b/mokkery-runtime/src/commonTest/kotlin/dev/mokkery/internal/verify/NotVerifierTest.kt
@@ -28,7 +28,7 @@ class NotVerifierTest {
         }
     }
     private val testRenderer = TestRenderer<NotVerifier.Error> { "RENDERED_ERROR" }
-    private val verifier = NotVerifier(callMatcher = callMatcher, errorRendererFactory = ::testRenderer)
+    private val verifier = NotVerifier(callMatcher = callMatcher, errorRenderer = testRenderer)
 
     @Test
     fun testFailsWhenMultipleCallsMatch() {
diff --git a/mokkery-runtime/src/commonTest/kotlin/dev/mokkery/internal/verify/OrderVerifierTest.kt b/mokkery-runtime/src/commonTest/kotlin/dev/mokkery/internal/verify/OrderVerifierTest.kt
diff --git a/mokkery-runtime/src/commonTest/kotlin/dev/mokkery/internal/verify/SoftVerifierTest.kt b/mokkery-runtime/src/commonTest/kotlin/dev/mokkery/internal/verify/SoftVerifierTest.kt
diff --git a/mokkery-runtime/src/commonTest/kotlin/dev/mokkery/matcher/logical/NotArgMatcherTest.kt b/mokkery-runtime/src/commonTest/kotlin/dev/mokkery/matcher/logical/NotArgMatcherTest.kt
diff --git a/test-mokkery/src/commonTest/kotlin/dev/mokkery/test/types/StubsTest.kt b/test-mokkery/src/commonTest/kotlin/dev/mokkery/test/types/StubsTest.kt
diff --git a/website/docs/Guides/Matchers.mdx b/website/docs/Guides/Matchers.mdx
diff --git a/website/docs/Limitations.mdx b/website/docs/Limitations.mdx
diff --git a/website/docs/Setup.mdx b/website/docs/Setup.mdx
diff --git a/website/src/versions.js b/website/src/versions.js

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@ package dev.mokkery.internal.verify`
`2`	`2`
`3`	`3`	`import dev.mokkery.internal.matcher.CallMatcher`
`4`	`4`	`import dev.mokkery.internal.matcher.isMatching`
`5`		`-import dev.mokkery.internal.render.RendererFactory`
	`5`	`+import dev.mokkery.internal.render.Renderer`
`6`	`6`	`import dev.mokkery.internal.templating.CallTemplate`
`7`	`7`	`import dev.mokkery.internal.tracing.CallTrace`
`8`	`8`	`import dev.mokkery.internal.verify.results.TemplateGroupedMatchingResults`
`@@ -11,7 +11,7 @@ internal class SoftVerifier(`
`11`	`11`	`private val atLeast: Int,`
`12`	`12`	`private val atMost: Int,`
`13`	`13`	`private val callMatcher: CallMatcher,`
`14`		`- private val errorRendererFactory: RendererFactory<Error>,`
	`14`	`+ private val errorRenderer: Renderer<Error>,`
`15`	`15`	`) : Verifier {`
`16`	`16`
`17`	`17`	`override fun verify(`
`@@ -28,7 +28,7 @@ internal class SoftVerifier(`
`28`	`28`	`calls = callTraces.groupBy { callMatcher.match(it, template) }`
`29`	`29`	`)`
`30`	`30`	`)`
`31`		`- throw AssertionError(errorRendererFactory.create().render(error))`
	`31`	`+ throw AssertionError(errorRenderer.render(error))`
`32`	`32`	`}`
`33`	`33`	`matching`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,26 +36,26 @@ private class VerifierFactoryImpl(`
`36`	`36`	`OrderVerifyMode -> OrderVerifier(`
`37`	`37`	`callMatcher = callMatcher,`
`38`	`38`	`resultsComposer = TemplateMatchingResultsComposer(callMatcher),`
`39`		`- errorRendererFactory = OrderVerifierErrorRenderer.factory(namesShortener, collection)`
	`39`	`+ errorRenderer = OrderVerifierErrorRenderer.lazy(namesShortener, collection)`
`40`	`40`	`)`
`41`	`41`	`ExhaustiveOrderVerifyMode -> ExhaustiveOrderVerifier(`
`42`	`42`	`resultsComposer = TemplateMatchingResultsComposer(callMatcher),`
`43`	`43`	`callMatcher = callMatcher,`
`44`		`- errorRendererFactory = ExhaustiveOrderVerifierErrorRenderer.factory(namesShortener, collection)`
	`44`	`+ errorRenderer = ExhaustiveOrderVerifierErrorRenderer.lazy(namesShortener, collection)`
`45`	`45`	`)`
`46`	`46`	`ExhaustiveSoftVerifyMode -> ExhaustiveSoftVerifier(`
`47`	`47`	`callMatcher = callMatcher,`
`48`		`- errorRendererFactory = ExhaustiveSoftVerifierErrorRenderer.factory(namesShortener, collection)`
	`48`	`+ errorRenderer = ExhaustiveSoftVerifierErrorRenderer.lazy(namesShortener, collection)`
`49`	`49`	`)`
`50`	`50`	`NotVerifyMode -> NotVerifier(`
`51`	`51`	`callMatcher = callMatcher,`
`52`		`- errorRendererFactory = NotVerifierErrorRenderer.factory(namesShortener, collection)`
	`52`	`+ errorRenderer = NotVerifierErrorRenderer.lazy(namesShortener, collection)`
`53`	`53`	`)`
`54`	`54`	`is SoftVerifyMode -> SoftVerifier(`
`55`	`55`	`atLeast = mode.atLeast,`
`56`	`56`	`atMost = mode.atMost,`
`57`	`57`	`callMatcher = callMatcher,`
`58`		`- errorRendererFactory = SoftVerifierErrorRenderer.factory(namesShortener, collection)`
	`58`	`+ errorRenderer = SoftVerifierErrorRenderer.lazy(namesShortener, collection)`
`59`	`59`	`)`
`60`	`60`	`}`
`61`	`61`	`}`