diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
index c9f79efb..7df69fb4 100644
--- a/.git-blame-ignore-revs
+++ b/.git-blame-ignore-revs
@@ -3,3 +3,6 @@ ff8ca52d610ca63ee0ab4fcfb5d79da13a1250b1
 
 # Scala Steward: Reformat with scalafmt 3.7.15
 8fa2251b493a78759fc04a2f74189b9f8bdc07c4
+
+# Scala Steward: Reformat with scalafmt 3.8.5
+901606cbce67fef00e7f1f646d4a60399a20e6e4
diff --git a/.scalafmt.conf b/.scalafmt.conf
index 5d93115d..860021b8 100644
--- a/.scalafmt.conf
+++ b/.scalafmt.conf
@@ -7,5 +7,5 @@ rewrite.rules = [RedundantBraces, RedundantParens, SortImports]
 spaces.inImportCurlyBraces = true
 indentOperator.preset = spray
 
-version=3.8.2
+version=3.8.5
 
diff --git a/common/src/main/scala/org/mockito/ReflectionUtils.scala b/common/src/main/scala/org/mockito/ReflectionUtils.scala
index 64057f9b..8f33e11e 100644
--- a/common/src/main/scala/org/mockito/ReflectionUtils.scala
+++ b/common/src/main/scala/org/mockito/ReflectionUtils.scala
@@ -20,9 +20,8 @@ object ReflectionUtils {
 
   private val mirror = runtimeMirror(getClass.getClassLoader)
   private val customMirror = mirror.asInstanceOf[{
-      def methodToJava(sym: Symbols#MethodSymbol): Method
-    }
-  ]
+    def methodToJava(sym: Symbols#MethodSymbol): Method
+  }]
 
   def listToTuple(l: List[Object]): Any =
     l match {
diff --git a/scalatest/src/test/scala/user/org/mockito/IdiomaticStubbingTest.scala b/scalatest/src/test/scala/user/org/mockito/IdiomaticStubbingTest.scala
index a9da2fe2..3cf6cb91 100644
--- a/scalatest/src/test/scala/user/org/mockito/IdiomaticStubbingTest.scala
+++ b/scalatest/src/test/scala/user/org/mockito/IdiomaticStubbingTest.scala
@@ -236,9 +236,8 @@ class IdiomaticStubbingTest extends AnyWordSpec with Matchers with ArgumentMatch
 
         org.doSomethingWithThisIntAndStringAndBoolean(1, "2", v3 = false)
 
-        an[IllegalArgumentException] should be thrownBy {
-          org.doSomethingWithThisIntAndStringAndBoolean(1, "2", v3 = true)
-        }
+        an[IllegalArgumentException] should be thrownBy
+        org.doSomethingWithThisIntAndStringAndBoolean(1, "2", v3 = true)
 
         """"some value" willBe thrown by org.bar""" shouldNot compile
       }
@@ -258,9 +257,8 @@ class IdiomaticStubbingTest extends AnyWordSpec with Matchers with ArgumentMatch
       aSpy.iBlowUp(1, "ok") shouldBe "mocked!"
       aSpy.iBlowUp(2, "ok") shouldBe "mocked!"
 
-      an[IllegalArgumentException] should be thrownBy {
-        aSpy.iBlowUp(2, "not ok")
-      }
+      an[IllegalArgumentException] should be thrownBy
+      aSpy.iBlowUp(2, "not ok")
     }
 
     "stub a function with an answer" in {
@@ -316,12 +314,11 @@ class IdiomaticStubbingTest extends AnyWordSpec with Matchers with ArgumentMatch
     }
 
     "be thread safe" when {
-      "always stubbing object methods" in {
-        immutable.ParSeq.range(1, 100).foreach { i =>
-          withObjectSpied[FooObject.type] {
-            FooObject.simpleMethod returns s"spied!-$i"
-            FooObject.simpleMethod shouldBe s"spied!-$i"
-          }
+      "always stubbing object methods" in
+      immutable.ParSeq.range(1, 100).foreach { i =>
+        withObjectSpied[FooObject.type] {
+          FooObject.simpleMethod returns s"spied!-$i"
+          FooObject.simpleMethod shouldBe s"spied!-$i"
         }
       }
 
@@ -357,12 +354,11 @@ class IdiomaticStubbingTest extends AnyWordSpec with Matchers with ArgumentMatch
       FooObject.simpleMethod shouldBe "not mocked!"
     }
 
-    "object stubbing should be thread safe" in {
-      immutable.ParSeq.range(1, 100).foreach { i =>
-        withObjectMocked[FooObject.type] {
-          FooObject.simpleMethod returns s"mocked!-$i"
-          FooObject.simpleMethod shouldBe s"mocked!-$i"
-        }
+    "object stubbing should be thread safe" in
+    immutable.ParSeq.range(1, 100).foreach { i =>
+      withObjectMocked[FooObject.type] {
+        FooObject.simpleMethod returns s"mocked!-$i"
+        FooObject.simpleMethod shouldBe s"mocked!-$i"
       }
     }
 
diff --git a/scalatest/src/test/scala/user/org/mockito/Issue256.scala b/scalatest/src/test/scala/user/org/mockito/Issue256.scala
index 6c1b97c9..00e19dc6 100644
--- a/scalatest/src/test/scala/user/org/mockito/Issue256.scala
+++ b/scalatest/src/test/scala/user/org/mockito/Issue256.scala
@@ -13,15 +13,14 @@ class Issue256 extends AnyWordSpec with Matchers {
   }
 
   "mockito" should {
-    "allow stubbing the same method multiple times" in {
-      MockitoScalaSession().run {
-        val foo = mock[Foo]
-        foo.test[String](argThat((s: String) => s.startsWith("foo"))) returns "foo"
-        foo.test[Int](argThat((n: Int) => n > 10)) returns 42
+    "allow stubbing the same method multiple times" in
+    MockitoScalaSession().run {
+      val foo = mock[Foo]
+      foo.test[String](argThat((s: String) => s.startsWith("foo"))) returns "foo"
+      foo.test[Int](argThat((n: Int) => n > 10)) returns 42
 
-        foo.test("fooSSS") shouldBe "foo"
-        foo.test(11) shouldBe 42
-      }
+      foo.test("fooSSS") shouldBe "foo"
+      foo.test(11) shouldBe 42
     }
   }
 }
diff --git a/scalatest/src/test/scala/user/org/mockito/MockitoScalaSessionTest.scala b/scalatest/src/test/scala/user/org/mockito/MockitoScalaSessionTest.scala
index f2357f87..f09b77e6 100644
--- a/scalatest/src/test/scala/user/org/mockito/MockitoScalaSessionTest.scala
+++ b/scalatest/src/test/scala/user/org/mockito/MockitoScalaSessionTest.scala
@@ -63,44 +63,40 @@ class MockitoScalaSessionTest extends AnyWordSpec with IdiomaticMockito with Mat
 
   forAll(scenarios) { (testDouble, foo, parametrisedFoo, fooBar) =>
     s"MockitoScalaSession - $testDouble" should {
-      "don't check unexpected calls for lenient methods (set at the beginning)" in {
-        MockitoScalaSession().run {
-          val aFoo = foo()
+      "don't check unexpected calls for lenient methods (set at the beginning)" in
+      MockitoScalaSession().run {
+        val aFoo = foo()
 
-          aFoo.bar(*).isLenient()
+        aFoo.bar(*).isLenient()
 
-          aFoo.bar("paco") shouldBe fooBar
-        }
+        aFoo.bar("paco") shouldBe fooBar
       }
 
-      "don't check unexpected calls for lenient methods (set at the end)" in {
-        MockitoScalaSession().run {
-          val aFoo = foo()
+      "don't check unexpected calls for lenient methods (set at the end)" in
+      MockitoScalaSession().run {
+        val aFoo = foo()
 
-          aFoo.bar("paco") shouldBe fooBar
+        aFoo.bar("paco") shouldBe fooBar
 
-          aFoo.bar(*).isLenient()
-        }
+        aFoo.bar(*).isLenient()
       }
 
-      "don't check unused stubs for lenient methods (set at the beginning)" in {
-        MockitoScalaSession().run {
-          val aFoo = foo()
+      "don't check unused stubs for lenient methods (set at the beginning)" in
+      MockitoScalaSession().run {
+        val aFoo = foo()
 
-          aFoo.bar(*).isLenient()
+        aFoo.bar(*).isLenient()
 
-          aFoo.bar("pepe") returns "mocked"
-        }
+        aFoo.bar("pepe") returns "mocked"
       }
 
-      "don't check unused stubs for lenient methods (set at the end)" in {
-        MockitoScalaSession().run {
-          val aFoo = foo()
+      "don't check unused stubs for lenient methods (set at the end)" in
+      MockitoScalaSession().run {
+        val aFoo = foo()
 
-          aFoo.bar("pepe") returns "mocked"
+        aFoo.bar("pepe") returns "mocked"
 
-          aFoo.bar(*).isLenient()
-        }
+        aFoo.bar(*).isLenient()
       }
 
       "check unused stubs" in {
@@ -112,24 +108,22 @@ class MockitoScalaSessionTest extends AnyWordSpec with IdiomaticMockito with Mat
           }
         }
 
-        an[UnnecessaryStubbingException] should be thrownBy {
-          MockitoScalaSession().run {
-            val aFoo = foo()
+        an[UnnecessaryStubbingException] should be thrownBy
+        MockitoScalaSession().run {
+          val aFoo = foo()
 
-            aFoo.unit().doesNothing()
-          }
+          aFoo.unit().doesNothing()
         }
       }
 
       "check incorrect stubs" in {
-        an[UnnecessaryStubbingException] should be thrownBy {
-          MockitoScalaSession().run {
-            val aFoo = foo()
+        an[UnnecessaryStubbingException] should be thrownBy
+        MockitoScalaSession().run {
+          val aFoo = foo()
 
-            aFoo.bar("pepe") returns "mocked"
+          aFoo.bar("pepe") returns "mocked"
 
-            aFoo.bar("paco").toLowerCase
-          }
+          aFoo.bar("paco").toLowerCase
         }
       }
 
@@ -150,103 +144,82 @@ class MockitoScalaSessionTest extends AnyWordSpec with IdiomaticMockito with Mat
       }
 
       "check unexpected invocations" in {
-        (the[UnexpectedInvocationException] thrownBy {
+        (the[UnexpectedInvocationException] thrownBy
           MockitoScalaSession().run {
             val aFoo = foo()
 
             aFoo.bar("pepe")
-          }
-        }).getMessage should startWith("Unexpected invocations found")
+          }).getMessage should startWith("Unexpected invocations found")
 
-        (the[UnexpectedInvocationException] thrownBy {
+        (the[UnexpectedInvocationException] thrownBy
           MockitoScalaSession().run {
             val aFoo = foo()
 
             aFoo.unit()
-          }
-        }).getMessage should startWith("Unexpected invocations found")
+          }).getMessage should startWith("Unexpected invocations found")
       }
 
-      "not check unexpected invocations if the call was verified" in {
-        MockitoScalaSession().run {
-          val aFoo = foo()
+      "not check unexpected invocations if the call was verified" in
+      MockitoScalaSession().run {
+        val aFoo = foo()
 
-          aFoo.bar("pepe")
+        aFoo.bar("pepe")
 
-          aFoo.bar("pepe") was called
-        }
+        aFoo.bar("pepe") was called
       }
 
       "check incorrect stubs with default arguments" in {
-        an[UnnecessaryStubbingException] should be thrownBy {
-          MockitoScalaSession().run {
-            val aFoo = foo()
-
-            aFoo.baz("pepe") returns "mocked"
-
-            aFoo.baz().toLowerCase
-          }
-        }
-      }
-
-      "work with default arguments" in {
+        an[UnnecessaryStubbingException] should be thrownBy
         MockitoScalaSession().run {
           val aFoo = foo()
 
-          aFoo.baz() returns "mocked"
+          aFoo.baz("pepe") returns "mocked"
 
-          aFoo.baz() shouldBe "mocked"
+          aFoo.baz().toLowerCase
         }
       }
 
-      "work with default arguments when passing an argument" in {
-        MockitoScalaSession().run {
-          val aFoo = foo()
+      "work with default arguments" in
+      MockitoScalaSession().run {
+        val aFoo = foo()
 
-          aFoo.baz("papa") returns "mocked"
+        aFoo.baz() returns "mocked"
 
-          aFoo.baz("papa") shouldBe "mocked"
-        }
+        aFoo.baz() shouldBe "mocked"
       }
 
-      "work with default arguments when passing an argument but production code doesn't" in {
-        MockitoScalaSession().run {
-          val aFoo = foo()
+      "work with default arguments when passing an argument" in
+      MockitoScalaSession().run {
+        val aFoo = foo()
 
-          aFoo.baz("default") returns "mocked"
+        aFoo.baz("papa") returns "mocked"
 
-          aFoo.baz() shouldBe "mocked"
-        }
+        aFoo.baz("papa") shouldBe "mocked"
       }
 
-      "don't check unexpected calls for lenient mocks" in {
-        MockitoScalaSession().run {
-          val aFoo = parametrisedFoo(withSettings.lenient())
+      "work with default arguments when passing an argument but production code doesn't" in
+      MockitoScalaSession().run {
+        val aFoo = foo()
 
-          aFoo.bar("pepe") returns "mocked"
+        aFoo.baz("default") returns "mocked"
 
-          aFoo.bar("pepe")
-
-          aFoo.bar("paco")
-        }
+        aFoo.baz() shouldBe "mocked"
       }
 
-      "check unexpected invocations for normal mocks" in {
-        a[UnexpectedInvocationException] should be thrownBy {
-          MockitoScalaSession().run {
-            val aFoo = foo()
+      "don't check unexpected calls for lenient mocks" in
+      MockitoScalaSession().run {
+        val aFoo = parametrisedFoo(withSettings.lenient())
 
-            aFoo.bar("pepe") returns "mocked"
+        aFoo.bar("pepe") returns "mocked"
 
-            aFoo.bar("pepe")
+        aFoo.bar("pepe")
 
-            aFoo.bar("paco")
-          }
-        }
+        aFoo.bar("paco")
       }
 
-      "don't check unexpected invocations in lenient setting" in {
-        MockitoScalaSession(strictness = Strictness.LENIENT).run {
+      "check unexpected invocations for normal mocks" in {
+        a[UnexpectedInvocationException] should be thrownBy
+        MockitoScalaSession().run {
           val aFoo = foo()
 
           aFoo.bar("pepe") returns "mocked"
@@ -257,100 +230,101 @@ class MockitoScalaSessionTest extends AnyWordSpec with IdiomaticMockito with Mat
         }
       }
 
-      "don't check unused stubs for lenient" in {
-        MockitoScalaSession().run {
-          val aFoo = parametrisedFoo(withSettings.lenient())
+      "don't check unexpected invocations in lenient setting" in
+      MockitoScalaSession(strictness = Strictness.LENIENT).run {
+        val aFoo = foo()
 
-          aFoo.bar("pepe") returns "mocked"
-        }
+        aFoo.bar("pepe") returns "mocked"
+
+        aFoo.bar("pepe")
+
+        aFoo.bar("paco")
       }
 
-      "check unused stubs for not lenient mocks" in {
-        a[UnnecessaryStubbingException] should be thrownBy {
-          MockitoScalaSession().run {
-            val aFoo = foo()
-            aFoo.bar("pepe") returns "mocked"
-          }
-        }
+      "don't check unused stubs for lenient" in
+      MockitoScalaSession().run {
+        val aFoo = parametrisedFoo(withSettings.lenient())
+
+        aFoo.bar("pepe") returns "mocked"
       }
 
-      "don't check unused stubs in lenient setting" in {
-        MockitoScalaSession(strictness = Strictness.LENIENT).run {
+      "check unused stubs for not lenient mocks" in {
+        a[UnnecessaryStubbingException] should be thrownBy
+        MockitoScalaSession().run {
           val aFoo = foo()
           aFoo.bar("pepe") returns "mocked"
         }
       }
 
+      "don't check unused stubs in lenient setting" in
+      MockitoScalaSession(strictness = Strictness.LENIENT).run {
+        val aFoo = foo()
+        aFoo.bar("pepe") returns "mocked"
+      }
+
       "check unused stubs in not lenient setting" in {
-        a[UnnecessaryStubbingException] should be thrownBy {
-          MockitoScalaSession(strictness = Strictness.STRICT_STUBS).run {
-            val aFoo = foo()
-            aFoo.bar("pepe") returns "mocked"
-          }
+        a[UnnecessaryStubbingException] should be thrownBy
+        MockitoScalaSession(strictness = Strictness.STRICT_STUBS).run {
+          val aFoo = foo()
+          aFoo.bar("pepe") returns "mocked"
         }
       }
     }
   }
 
   "MockitoScalaSession" should {
-    "don't fail if equals calls on an internal method" in {
-      MockitoScalaSession().run {
-        val aFoo = mock[Foo]
+    "don't fail if equals calls on an internal method" in
+    MockitoScalaSession().run {
+      val aFoo = mock[Foo]
 
-        aFoo.finalFinalEqualsAndHashcode
+      aFoo.finalFinalEqualsAndHashcode
 
-        aFoo.finalFinalEqualsAndHashcode was called
-      }
+      aFoo.finalFinalEqualsAndHashcode was called
     }
 
     "re-throw an exception produced by the test" in {
-      an[IllegalArgumentException] should be thrownBy {
-        MockitoScalaSession().run {
-          throw new IllegalArgumentException
-        }
+      an[IllegalArgumentException] should be thrownBy
+      MockitoScalaSession().run {
+        throw new IllegalArgumentException
       }
     }
 
     "re-throw an real NPE produced by the test (an NPE not related to an un-stubbed mock call)" in {
-      an[NullPointerException] should be thrownBy {
-        MockitoScalaSession().run {
-          throw new NullPointerException
-        }
+      an[NullPointerException] should be thrownBy
+      MockitoScalaSession().run {
+        throw new NullPointerException
       }
     }
 
-    "work with nested deep stubs" in {
-      MockitoScalaSession().run {
-        val aFoo = mock[Foo](DefaultAnswers.ReturnsDeepStubs)
+    "work with nested deep stubs" in
+    MockitoScalaSession().run {
+      val aFoo = mock[Foo](DefaultAnswers.ReturnsDeepStubs)
 
-        aFoo.userClass.callMeMaybe.callMe returns Some("my number")
+      aFoo.userClass.callMeMaybe.callMe returns Some("my number")
 
-        aFoo.userClass.callMeMaybe.callMe.value shouldBe "my number"
-      }
+      aFoo.userClass.callMeMaybe.callMe.value shouldBe "my number"
     }
 
-    "not fail if a final deep stub is called in a non stubbed method" in {
-      MockitoScalaSession().run {
-        val aFoo = mock[Foo](DefaultAnswers.ReturnsDeepStubs)
+    "not fail if a final deep stub is called in a non stubbed method" in
+    MockitoScalaSession().run {
+      val aFoo = mock[Foo](DefaultAnswers.ReturnsDeepStubs)
 
-        aFoo.userClass.callMeMaybe.callMe returns Some("my number")
+      aFoo.userClass.callMeMaybe.callMe returns Some("my number")
 
-        aFoo.userClass.callMeMaybe.callMe.value shouldBe "my number"
+      aFoo.userClass.callMeMaybe.callMe.value shouldBe "my number"
 
-        aFoo.userClass.callMeMaybe.dontCallMe
-      }
+      aFoo.userClass.callMeMaybe.dontCallMe
     }
 
-    "not fail if a nested deep stub is called in a non stubbed method" in {
-      MockitoScalaSession().run {
-        val aFoo = mock[Foo](DefaultAnswers.ReturnsDeepStubs)
+    "not fail if a nested deep stub is called in a non stubbed method" in
+    MockitoScalaSession().run {
+      val aFoo = mock[Foo](DefaultAnswers.ReturnsDeepStubs)
 
-        aFoo.userClass.callMeMaybe.callMe returns Some("my number")
+      aFoo.userClass.callMeMaybe.callMe returns Some("my number")
 
-        aFoo.userClass.callMeMaybe.callMe.value shouldBe "my number"
+      aFoo.userClass.callMeMaybe.callMe.value shouldBe "my number"
 
-        aFoo.userClass.dontCallMe
-      }
+      aFoo.userClass.dontCallMe
     }
 
     "fail if a nested deep stub is stubbed but not used" in {
@@ -391,15 +365,14 @@ class MockitoScalaSessionTest extends AnyWordSpec with IdiomaticMockito with Mat
 
     "verify object spies" when {
 
-      "successfully for uncalled lenient stubs" in {
-        MockitoScalaSession().run {
-          import org.mockito.leniency.lenient
+      "successfully for uncalled lenient stubs" in
+      MockitoScalaSession().run {
+        import org.mockito.leniency.lenient
 
-          withObjectSpied[FooObject.type] {
-            FooObject.stateDependantMethod returns 1234L
-            FooObject.simpleMethod returns s"spied!"
-            FooObject.simpleMethod shouldBe s"spied!"
-          }
+        withObjectSpied[FooObject.type] {
+          FooObject.stateDependantMethod returns 1234L
+          FooObject.simpleMethod returns s"spied!"
+          FooObject.simpleMethod shouldBe s"spied!"
         }
       }
 
diff --git a/scalatest/src/test/scala/user/org/mockito/MockitoSugarTest.scala b/scalatest/src/test/scala/user/org/mockito/MockitoSugarTest.scala
index d73e7d63..9381b302 100644
--- a/scalatest/src/test/scala/user/org/mockito/MockitoSugarTest.scala
+++ b/scalatest/src/test/scala/user/org/mockito/MockitoSugarTest.scala
@@ -408,9 +408,8 @@ class MockitoSugarTest extends AnyWordSpec with MockitoSugar with Matchers with
     }
 
     "stop the user passing traits in the settings" in {
-      a[IllegalArgumentException] should be thrownBy {
-        mock[Foo](withSettings.extraInterfaces(classOf[Baz]))
-      }
+      a[IllegalArgumentException] should be thrownBy
+      mock[Foo](withSettings.extraInterfaces(classOf[Baz]))
     }
 
     "work when getting varargs from collections" in {
diff --git a/scalatest/src/test/scala/user/org/mockito/matchers/ThatMatchersTest.scala b/scalatest/src/test/scala/user/org/mockito/matchers/ThatMatchersTest.scala
index 8b9b2a90..23090c1c 100644
--- a/scalatest/src/test/scala/user/org/mockito/matchers/ThatMatchersTest.scala
+++ b/scalatest/src/test/scala/user/org/mockito/matchers/ThatMatchersTest.scala
@@ -25,9 +25,8 @@ class ThatMatchersTest extends AnyFlatSpec with MockitoSugar with Matchers with
     verify(aMock).baz(argMatching { case Baz("Hello", _) => })
     verify(aMock).baz(argMatching { case Baz(_, _) => })
 
-    an[WantedButNotInvoked] should be thrownBy {
-      verify(aMock).baz(argMatching { case Baz("", _) => })
-    }
+    an[WantedButNotInvoked] should be thrownBy
+    verify(aMock).baz(argMatching { case Baz("", _) => })
   }
 
   "argThat[T]" should "work with AnyRef" in {
diff --git a/specs2/src/main/scala/org/mockito/specs2/MockitoSpecs2Support.scala b/specs2/src/main/scala/org/mockito/specs2/MockitoSpecs2Support.scala
index 3646fa19..64615ede 100644
--- a/specs2/src/main/scala/org/mockito/specs2/MockitoSpecs2Support.scala
+++ b/specs2/src/main/scala/org/mockito/specs2/MockitoSpecs2Support.scala
@@ -85,8 +85,17 @@ trait FunctionArguments extends FunctionArgumentsLowImplicits {
   implicit def matcherToFunctionCall7[T1, T2, T3, T4, T5, T6, T7, R](values: ((T1, T2, T3, T4, T5, T6, T7), Matcher[R])): Function7[T1, T2, T3, T4, T5, T6, T7, R] =
     callMatching7(values._1._1, values._1._2, values._1._3, values._1._4, values._1._5, values._1._6, values._1._7, values._2)
 
-  def callMatching8[T1, T2, T3, T4, T5, T6, T7, T8, R](t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, m: Matcher[R])
-      : Function8[T1, T2, T3, T4, T5, T6, T7, T8, R] =
+  def callMatching8[T1, T2, T3, T4, T5, T6, T7, T8, R](
+      t1: T1,
+      t2: T2,
+      t3: T3,
+      t4: T4,
+      t5: T5,
+      t6: T6,
+      t7: T7,
+      t8: T8,
+      m: Matcher[R]
+  ): Function8[T1, T2, T3, T4, T5, T6, T7, T8, R] =
     argThat(m ^^ { (f: Function8[T1, T2, T3, T4, T5, T6, T7, T8, R]) => f(t1, t2, t3, t4, t5, t6, t7, t8) })
   def functionCall8[T1, T2, T3, T4, T5, T6, T7, T8, R](t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, r: R): Function8[T1, T2, T3, T4, T5, T6, T7, T8, R] =
     callMatching8(t1, t2, t3, t4, t5, t6, t7, t8, new BeEqualTo(r))
@@ -95,11 +104,31 @@ trait FunctionArguments extends FunctionArgumentsLowImplicits {
   implicit def matcherToFunctionCall8[T1, T2, T3, T4, T5, T6, T7, T8, R](values: ((T1, T2, T3, T4, T5, T6, T7, T8), Matcher[R])): Function8[T1, T2, T3, T4, T5, T6, T7, T8, R] =
     callMatching8(values._1._1, values._1._2, values._1._3, values._1._4, values._1._5, values._1._6, values._1._7, values._1._8, values._2)
 
-  def callMatching9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R](t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, m: Matcher[R])
-      : Function9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R] =
+  def callMatching9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R](
+      t1: T1,
+      t2: T2,
+      t3: T3,
+      t4: T4,
+      t5: T5,
+      t6: T6,
+      t7: T7,
+      t8: T8,
+      t9: T9,
+      m: Matcher[R]
+  ): Function9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R] =
     argThat(m ^^ { (f: Function9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]) => f(t1, t2, t3, t4, t5, t6, t7, t8, t9) })
-  def functionCall9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R](t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, r: R)
-      : Function9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R] = callMatching9(t1, t2, t3, t4, t5, t6, t7, t8, t9, new BeEqualTo(r))
+  def functionCall9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R](
+      t1: T1,
+      t2: T2,
+      t3: T3,
+      t4: T4,
+      t5: T5,
+      t6: T6,
+      t7: T7,
+      t8: T8,
+      t9: T9,
+      r: R
+  ): Function9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R] = callMatching9(t1, t2, t3, t4, t5, t6, t7, t8, t9, new BeEqualTo(r))
   implicit def toFunctionCall9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R](values: ((T1, T2, T3, T4, T5, T6, T7, T8, T9), R)): Function9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R] =
     functionCall9(values._1._1, values._1._2, values._1._3, values._1._4, values._1._5, values._1._6, values._1._7, values._1._8, values._1._9, values._2)
   implicit def matcherToFunctionCall9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R](