| Q | A | --------------------| --------------- | PHPUnit version | 9.5.5 | PHP version | 8.0.6 | Installation Method | Composer

Summary

When mocking a method which returns false|int, I get the error below.

There was 1 error:

1) AckintoshTest::test
PHPUnit\Framework\MockObject\IncompatibleReturnValueException: Method foo may not return value of type boolean, its return declaration is "false|int"

How to reproduce

<?php
use PHPUnit\Framework\TestCase;

class AckintoshTest extends TestCase
{
    /**
     * @test
     */
    public function test()
    {
        $m = $this->getMockBuilder(Ackintosh::class)
                  ->setMethods(['foo'])
                  ->getMock();
        $m->expects($this->once())
          ->method('foo')
          ->willReturn(false);

        $this->assertFalse($m->foo());
    }
}

class Ackintosh
{
    function foo(): false|int
    {
        return false;
    }
}

$ vendor/bin/phpunit .

PHPUnit 9.5.5 by Sebastian Bergmann and contributors.

Warning:       No code coverage driver available

E                                                                   1 / 1 (100%)

Time: 00:00.023, Memory: 6.00 MB

There was 1 error:

1) AckintoshTest::test
PHPUnit\Framework\MockObject\IncompatibleReturnValueException: Method foo may not return value of type boolean, its return declaration is "false|int"

/Users/abi01357/test/phpunit/tests/AckintoshTest.php:16

Expected behavior

The mock returns false.

This should fix the issue raised here. Basically, this allows object types to be assignable from object. Before, we were only checking if the object was the same class or a subclass of the type you're trying to assign to.

Noticed some more improvements to be made, thought I'd waste some time doing just that.

Needless to say, this is a BC-break because of all the method-to-public-property changes.

I see that CI/Coding Guidelines fails because of braces php-cs-fixer rule; that is because php-cs-fixer does not yet support constructor property promotion, it wants the empty braces to be split into two lines.

Hi,

I was evaluating this library today for a custom typed generator that I'm developing and I noticed something and I wanted to share what I have in mind.

Current code:

private function ensureNoDuplicateTypes(Type ...$types): void
{
  $names = [];
  
  foreach ($types as $type) {
      assert($type instanceof ObjectType);
  
      $names[] = $type->className()->qualifiedName();
  }
  
  if (count(array_unique($names)) < count($names)) {
      throw new RuntimeException(
          'An intersection type must not contain duplicate types'
      );
  }
}

The time complexity for this would be:

• foreach loop: $\mathcal{O}(n)$
• first count: $\mathcal{O}(1)$
• array_unique:
  • Worst case: $\mathcal{O}(n)$
  • Best case: $\Omega(n)$
• second count: $\mathcal{O}(1)$

What matter here in this snippet is that, no matter how many groups of duplicates $types contains, it will always traverse the full array, this is why $\mathcal{O}(n) == \Omega(n)$ in the first case. However, what we are looking for here, is to throw an exception as soon as there is a duplicate.

And here we have two scenarios:

• worst case scenario( $\mathcal{O}$ ): the last item is a duplicate
• best case scenario( $\Omega$ ): the second item is a duplicate

Here's what I propose:

private function ensureNoDuplicateTypes(Type ...$types): void
{
  $names = [];
  
  foreach ($types as $type) {
      assert($type instanceof ObjectType);
  
      $classQualifiedName = $type->className()->qualifiedName();
  
      $names[] = in_array($classQualifiedName, $names, true)
          ? throw new RuntimeException('An intersection type must not contain duplicate types')
          : $classQualifiedName;
  }
}

What I propose is to break the loop as soon as a duplicate is found.

The time complexity for this would be:

• foreach loop: $\mathcal{O}(n)$
• in_array:
  • Worst case: $\mathcal{O}(n)$
  • Best case: $\mathcal{O}(2)$
  • Between best and worst cases: $\mathcal{O}(m)$ with $(m < n)$

What do you think? Actually I often see such things in PHP here and there and I'm wondering if introducing pull-requests for changing these kind of subtle things make sense. Do you think it worth submitting a PR ?

Thanks in advance.

@stof wrote:

2 types allowing null are not automatically assignable to each other. Null is assignable to a type allowing null. And a type allowing null is not assignable to a type not allowing null. But ?string is not assignable to ?int

I'm not sure if you want this, but I would find it useful if this package was able to parse union type names and nullables. I implemented it in one of my projects using your package and thought "maybe it could be interesting for the main package too" :)

Newest PHPUnit version 8.2.0 gives us a lot of warnings ("Method ... may not return value of type array") when mocking methods which have "iterable" as return type hint and giving arrays as return value.

Perhaps this should be its own Type-Class here?

As part of https://github.com/sebastianbergmann/phpunit/issues/4879 you mentioned you were happy to accept pull requests for backporting union types into PHPUnit 8. As that ships with v1 of types this does a equivalent backport of both Union and Intersection types (as I was doing the union ones in the first place).

This PR

• [x] switches to using GitHub Actions instead of Travis CI

Fixes #7.

💁‍♂ Note that GitHub Actions aren't triggered here because I'm pushing from a fork and the workflow does not exist yet.

PHP 8.2 adds support for Disjunctive Normal Form Types:

This RFC does not introduce any new reflection classes. However, it does make one change to the Reflection API, in that ReflectionUnionType::getTypes() previously was guaranteed to always return an array of ReflectionNamedType instances. Now it will return some combination of ReflectionNamedType and ReflectionIntersectionType instances. The method is already typed to return ReflectionType so this is not an API change, but the previous de facto assumption is no longer valid.

Reverts 6a84c28d0af3f09ffd407b0391796a87d2c07b07

https://github.com/php/php-src/pull/7546 has been merged so these tests can be "unskipped".

This issue comes to me when I try to mock method in PHPUnit witch returns Some_Class_Name but this is a class alias and real class name is like \Some\Class\Name.

Code is better than 1000 words, so I prepare PR: https://github.com/sebastianbergmann/type/pull/17