Revert "Closes #6498"

This reverts commit 6b0c3a2.

Author: sebastianbergmann

src/Framework/MockObject/Runtime/AbstractInvocationImplementation.php

@@ -218,7 +218,7 @@ final public function willThrowException(Throwable $exception): InvocationStubbe
 
     final public function seal(): void
     {
-        $this->invocationHandler->seal();
+        $this->invocationHandler->seal($this->invocationHandler->isMockObject());
     }
 
     /**

src/Framework/MockObject/Runtime/Api/Method.php

@@ -10,6 +10,7 @@
 namespace PHPUnit\Framework\MockObject;
 
 use PHPUnit\Framework\Constraint\Constraint;
+use PHPUnit\Framework\MockObject\Rule\AnyInvokedCount;
 use PHPUnit\Framework\MockObject\Runtime\PropertyHook;
 
 /**
@@ -25,7 +26,7 @@ public function method(Constraint|PropertyHook|string $constraint): InvocationSt
     {
         return $this
             ->__phpunit_getInvocationHandler()
-            ->configureStub()
+            ->expects(new AnyInvokedCount)
             ->method($constraint);
     }
 }

src/Framework/MockObject/Runtime/Api/MockObjectApi.php

@@ -9,7 +9,6 @@
  */
 namespace PHPUnit\Framework\MockObject;
 
-use function assert;
 use PHPUnit\Framework\MockObject\Rule\InvocationOrder;
 
 /**
@@ -43,10 +42,6 @@ abstract public function __phpunit_unsetInvocationMocker(): void;
 
     public function expects(InvocationOrder $matcher): InvocationMocker
     {
-        $handler = $this->__phpunit_getInvocationHandler();
-
-        assert($handler instanceof MockObjectInvocationHandler);
-
-        return $handler->expects($matcher);
+        return $this->__phpunit_getInvocationHandler()->expects($matcher);
     }
 }

src/Framework/MockObject/Runtime/Api/TestDoubleState.php

@@ -40,17 +40,11 @@ public function invocationHandler(): InvocationHandler
             return $this->invocationHandler;
         }
 
-        if ($this->isMockObject) {
-            $this->invocationHandler = new MockObjectInvocationHandler(
-                $this->configurableMethods,
-                $this->generateReturnValues,
-            );
-        } else {
-            $this->invocationHandler = new TestStubInvocationHandler(
-                $this->configurableMethods,
-                $this->generateReturnValues,
-            );
-        }
+        $this->invocationHandler = new InvocationHandler(
+            $this->configurableMethods,
+            $this->generateReturnValues,
+            $this->isMockObject,
+        );
 
         return $this->invocationHandler;
     }

src/Framework/MockObject/Runtime/InvocationHandler.php

@@ -10,23 +10,23 @@
 namespace PHPUnit\Framework\MockObject;
 
 use function array_any;
+use function array_unique;
+use function array_values;
+use function in_array;
 use function strtolower;
 use Exception;
-use PHPUnit\Framework\MockObject\Rule\AnyInvokedCount;
+use PHPUnit\Framework\MockObject\Rule\InvocationOrder;
+use PHPUnit\Framework\MockObject\Rule\InvokedCount;
+use PHPUnit\Framework\MockObject\Rule\MethodName;
 use Throwable;
 
 /**
  * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
  *
  * @internal This class is not covered by the backward compatibility promise for PHPUnit
  */
-abstract class InvocationHandler
+final class InvocationHandler
 {
-    /**
-     * @var list<ConfigurableMethod>
-     */
-    protected readonly array $configurableMethods;
-
     /**
      * @var list<Matcher>
      */
@@ -36,16 +36,28 @@ abstract class InvocationHandler
      * @var array<non-empty-string, Matcher>
      */
     private array $matcherMap = [];
+
+    /**
+     * @var list<ConfigurableMethod>
+     */
+    private readonly array $configurableMethods;
     private readonly bool $returnValueGeneration;
+    private readonly bool $isMockObject;
     private bool $sealed = false;
 
     /**
      * @param list<ConfigurableMethod> $configurableMethods
      */
-    public function __construct(array $configurableMethods, bool $returnValueGeneration)
+    public function __construct(array $configurableMethods, bool $returnValueGeneration, bool $isMockObject = false)
     {
         $this->configurableMethods   = $configurableMethods;
         $this->returnValueGeneration = $returnValueGeneration;
+        $this->isMockObject          = $isMockObject;
+    }
+
+    public function isMockObject(): bool
+    {
+        return $this->isMockObject;
     }
 
     public function hasMatchers(): bool
@@ -86,16 +98,23 @@ public function registerMatcher(string $id, Matcher $matcher): void
     /**
      * @throws TestDoubleSealedException
      */
-    public function configureStub(): InvocationStubber
+    public function expects(InvocationOrder $rule): InvocationMocker|InvocationStubber
     {
-        if ($this->isSealed()) {
+        if ($this->sealed) {
             throw new TestDoubleSealedException;
         }
 
-        $matcher = new Matcher(new AnyInvokedCount);
-
+        $matcher = new Matcher($rule);
         $this->addMatcher($matcher);
 
+        if ($this->isMockObject) {
+            return new InvocationMockerImplementation(
+                $this,
+                $matcher,
+                ...$this->configurableMethods,
+            );
+        }
+
         return new InvocationStubberImplementation(
             $this,
             $matcher,
@@ -157,28 +176,64 @@ public function verify(): void
         }
     }
 
-    public function isSealed(): bool
+    public function seal(bool $isMockObject): void
     {
-        return $this->sealed;
-    }
+        if ($this->sealed) {
+            return;
+        }
+
+        $this->sealed = true;
+
+        if (!$isMockObject) {
+            return;
+        }
+
+        $configuredMethods = $this->configuredMethodNames();
+
+        foreach ($this->configurableMethods as $method) {
+            if (!in_array($method->name(), $configuredMethods, true)) {
+                $matcher = new Matcher(new InvokedCount(0));
 
-    abstract public function seal(): void;
+                $matcher->setMethodNameRule(new MethodName($method->name()));
 
-    protected function addMatcher(Matcher $matcher): void
+                $this->addMatcher($matcher);
+            }
+        }
+    }
+
+    public function isSealed(): bool
     {
-        $this->matchers[] = $matcher;
+        return $this->sealed;
     }
 
-    protected function markSealed(): void
+    private function addMatcher(Matcher $matcher): void
     {
-        $this->sealed = true;
+        $this->matchers[] = $matcher;
     }
 
     /**
-     * @return list<Matcher>
+     * Returns the list of method names that have been configured with expectations.
+     * Only considers exact string matches for method names.
+     * Methods with any() expectation are considered configured.
+     *
+     * @return list<non-empty-string>
      */
-    protected function matchers(): array
+    private function configuredMethodNames(): array
     {
-        return $this->matchers;
+        $names = [];
+
+        foreach ($this->matchers as $matcher) {
+            if (!$matcher->hasMethodNameRule()) {
+                continue;
+            }
+
+            foreach ($this->configurableMethods as $method) {
+                if ($matcher->methodNameRule()->matchesName($method->name())) {
+                    $names[] = $method->name();
+                }
+            }
+        }
+
+        return array_values(array_unique($names));
     }
 }