Add support for inheritance in #[Friend]

[alek-as]

The library works very well for most of our use cases, thank you for creating it!

We've recently discovered that adding #[Friend] annotation with an interface as friend class will produce an error when the method is called from implementation classes.

See below for simple code snippet:

<?php

declare(strict_types=1);

namespace App;

use DaveLiddament\PhpLanguageExtensions\Friend;

interface Foo
{
}

class Bar
{
    #[Friend(Foo::class)]
    public function bar(): void
    {
    }
}

class Baz implements Foo
{
    public function baz(): void
    {
        $bar = new Bar();

        $bar->bar();
    }
}

Produced error:

------ ----------------------------------------------------------------------------------------------- 
  Line   src/Foo.php                                                                                    
 ------ ----------------------------------------------------------------------------------------------- 
  27     App\Bar::bar cannot be called from App\Baz, it can only be called from its friend(s): App\Foo  
 ------ -----------------------------------------------------------------------------------------------

Is this error intentional?

[DaveLiddament]

The original design was for friends to specify the exact class, however your suggestion makes a lot of sense, so I will look to get this implemented.

[DaveLiddament]

@alek-as have you got a more real life example you'd be happy to share? Having something real, rather than abstract will probably help me implement the correct thing.

@alek-as (cc @tomadam)
I've added a few examples in PR #36, looks for the lines of code that end // OK and // ERROR for examples of code that I think should and should not work. Do you agree with these? Also if you have any more to add that'd be great too.

Thanks

[alek-as]

@DaveLiddament

In our case, the Friend attribute needed to be added on a class method, not an interface method. See below for more generalized example:

<?php

declare(strict_types=1);

namespace App;

use DaveLiddament\PhpLanguageExtensions\Friend;

interface Invoice
{
}

class InvoiceLine
{
    #[Friend(Invoice::class)]
    public function changeAmount(int $newAmount): void
    {
    }
}

class RegularInvoice implements Invoice
{
    /**
     * @var array<InvoiceLine>
     */
    private array $invoiceLines;

    public function changeInvoiceLineAmount(InvoiceLine $line, int $newAmount): void
    {
        // verify that the invoice line belongs to this invoice
        // protect some invariants

        $line->changeAmount($newAmount);
    }
}

The examples from PR look good, not sure if adding another one is necessary (I'd assume above case will also be covered now)

[heiglandreas]

The same issue pops up when using Friends on a subclass.

We run into this when wanting to only allow calls to a certain function from within test-runs bot not production code.

So our setup is similar to this one:

class MyClass {
	#[Friend(PHPUnit\Framework\TestCase::class)]
    public function clearCache(): void 
	{
		// We clear a cache that is created but needs to be dumped during test-runs
	}
}

class TestClass extends PHPUnit\Framework\TestCase
{
	public function testCacheClearing(): void
    {
		$class = new MyClass();
		// This should not be marked as an issue
		$class->clearCache();
	}
}

class Whatever
{
	public function doStuff(MyClass $class): void
    {
		// This call should result in an error in PHPStan
		$class->clearCache();
	}
}

This would allow us to call MyClass::clearCache() in all tests but never in production code.

[DaveLiddament]

@heiglandreas I'd take a look at #[TestTag] for that purpose (see here.

I'll take a look at this and also TestTag, so that it works on subclasses.