Why does Mockito throw up when accessing a mock while verifying another one?

See this example:

class Foo { }

class Bar {
    void takeIt(int i, String arg) { System.out.println(arg + i); }
}

public class Mcve {    
    @Test
    public void passes() {
        Foo foo = Mockito.mock(Foo.class);
        Bar bar = Mockito.mock(Bar.class);
        bar.takeIt(42, "surprise: " + foo);
        String substring = "surprise: " + foo;
        Mockito.verify(bar).takeIt(ArgumentMatchers.eq(42),
                ArgumentMatchers.contains(substring));
    }

    @Test
    public void fails() {
        Foo foo = Mockito.mock(Foo.class);
        Bar bar = Mockito.mock(Bar.class);
        bar.takeIt(42, "surprise: " + foo);
        Mockito.verify(bar).takeIt(ArgumentMatchers.eq(42),
                ArgumentMatchers.contains("surprise: " + foo));
    }    
}

The two tests are almost identical, the only difference: the string used for the contains() matcher is computed upfront in passes(), but inlined in fails().

fails() throws up:

org.mockito.exceptions.misusing.InvalidUseOfMatchersException: 
Invalid use of argument matchers!
0 matchers expected, 1 recorded:
-> at com.ibm.hwmca.z.svm.zhyp.managed.Mcve.fails(Mcve.java:43)

This exception may occur if matchers are combined with raw values:
    //incorrect:
    someMethod(anyObject(), "raw String");
When using matchers, all arguments have to be provided by matchers.
For example:
    //correct:
    someMethod(anyObject(), eq("String by matcher"));

For more info see javadoc for Matchers class.


	at java.lang.String.valueOf(String.java:2994)
	at java.lang.StringBuilder.append(StringBuilder.java:131)
	at Mcve.fails(Mcve.java:43)
...

(Obviously: the error message is plain wrong, as the above code is using a matcher for all parameters)

Even more interesting: it only fails with more than 1 argument to match on (if one removes the int parameter from gimme(), and just passes/matches that string argument: pass).

Can anyone explain exactly what is happening here, and is there a way to do such a matching like contains("surprise: " + foo), with foo being something Mockito-mocked?

Of course, this is really meant as MCVE. It took me 3 hours to get from the failing unit test in our environment to this example here.

In the real environment, the Bar class is a mocked logging facility.
And the Foo object represents some "data entity" that gets created by some fake persistence layer. I have to verify that the production code does log specific information, and some of that information is derived from the faked data objects.