verify verifies against wrong class when a second mock is called within the same verify call

[Clavum]

This issue is best explained and demonstrated in code. There is a comment that explains the issue.

Mocktail 0.3.0

import 'package:flutter_test/flutter_test.dart';
import 'package:mocktail/mocktail.dart';

class SomeDataProvider {
  String getValue() => 'value';
}

class SomeClassToMockAndVerify {
  void doSomethingImportant(String value) {}
}

class SubjectUnderTest {
  final SomeDataProvider _someDataProvider;
  final SomeClassToMockAndVerify _someClassToMockAndVerify;

  SubjectUnderTest(this._someDataProvider, this._someClassToMockAndVerify);

  void methodUnderTest() {
    // You'll see what this is for later:
    _someDataProvider.getValue();
    _someDataProvider.getValue();
    _someDataProvider.getValue();
    _someDataProvider.getValue();
    _someDataProvider.getValue();

    _someClassToMockAndVerify.doSomethingImportant(
      _someDataProvider.getValue(),
    );
  }
}

class MockSomeDataProvider extends Mock implements SomeDataProvider {}

class MockSomeClassToMockAndVerify extends Mock implements SomeClassToMockAndVerify {}

void main() {
  test('bug example', () {
    final mockSomeDataProvider = MockSomeDataProvider();
    when(() => mockSomeDataProvider.getValue()).thenReturn('mock value');
    final mockSomeClassToMockAndVerify = MockSomeClassToMockAndVerify();

    final subjectUnderTest = SubjectUnderTest(
      mockSomeDataProvider,
      mockSomeClassToMockAndVerify,
    );
    subjectUnderTest.methodUnderTest();

    verify(
      () => mockSomeClassToMockAndVerify.doSomethingImportant(
        // Whoops! Here we accidentally call a method of a *second* mock during a verify call. Now,
        // the verification is broken, and is verifying `mockSomeDataProvider`'s calls instead of
        // `mockSomeClassToMockAndVerify`'s calls!
        // As evidence of this, the test fails saying there were 6 calls instead of 1.
        // This is very confusing as a developer, since we're verifying `doSomethingImportant` and
        // being told it was called 6 times when it was only called once.
        // Of course, we should use the literal 'mock value' string here, but my ask is just that
        // this scenario be better handled, perhaps with a special exception.
        mockSomeDataProvider.getValue(),
      ),
    ).called(1);
    // Expected: <1>
    // Actual: <6>
    // Unexpected number of calls
  });
}