namespace Foo {

  class Person 
  {
    #[Package]
    public function __construct(
      private string $name;
    ) {
    }
    
    #[Package]
    public function updateName(string $name): void
    {
        $this->name = $name;
    }
    
    public function getName(): string
    {
       return $this->name;
    }
  }

  class PersonFactory
  {
    public static function create(string $name): Person
    {
      return new Person($name); // This is allowed
    }
  }
}

namespace Bar {

  class Demo 
  {
    public function allowed(): void 
    {
      // Code below is OK. Only calling public methods
      $jane = PersonBuilder::create("Jane");
      echo $jane->getName();
    }
  
    public function notAllowed1(Person $person): void
    {
      // ERROR with line below: `update` method has package visibility. It can only be called from the '`Foo` namespace.
      $person->updateName("Robert")
    }
  
    public function notAllowed2(): void
    {
      // ERROR with line below. Person's __construct method has package visibility. It can only be called by code in the `Foo` namespace.
      $jane = new Person(); 
    }
  }
}

namespace Foo {

  #[Package]
  class Mailer 
  {
    public function sendMessage(string $message): void
    {
      // Some implementation
    } 
  }
}

namespace Bar {

  class PdfSender
  {
    public function __invoke(Mailer $mailer): void
    {
      // ERROR: The method Mailer::sendMessage is on a package level class. 
      $mailer->sendMessage("some message");
    }
  }

}

class Person
{
    #[Friend(PersonBuilder::class)]
    public function __construct()
    {
        // Some implementation
    }
}


class PersonBuilder
{
    public function build(): Person
    {
        $person = new Person(): // OK PersonBuilder is a friend of Person
        // set up Person
        return $person;
    }
}


// ERROR Call to Person::__construct is not from PersonBuilder
$person = new Person();

#[Sealed([Success::class, Failure::class])]
abstract class Result {} // Result can only be extended by Success or Failure

// OK
class Success extends Result {}

// OK
class Failure extends Result {}

// ERROR AnotherClass is not allowed to extend Result
class AnotherClass extends Result {}

class Person {

    #[TestTag]
    public function setId(int $id) 
    {
      $this->id = $id;
    }
}


function updatePersonId(Person $person): void 
{
    $person->setId(10);  // ERROR - not test code.
}


class PersonTest 
{
    public function setup(): void
    {
        $person = new Person();
        $person->setId(10); // OK - This is test code.
    }
}

#[InjectableVersion]
class PersonRepository {...} // This is the version that should be type hinted in constructors.

class DoctrinePersonRepository extends PersonRepository {...}

class PersonCreator {
    public function __construct(
        private PersonRepository $personRepository, // OK - using the injectable version
    )
}
class PersonUpdater {
    public function __construct(
        private DoctrinePersonRepository $personRepository, // ERROR - not using the InjectableVersion
    )
}

#[InjectableVersion]
interface Validator {...} // This is the version that should be type hinted in constructors.

class NameValidator implements Validator {...}
class AddressValidator implements Validator {...}

class PersonValidator {
    /** @param Validator[] $validators */
    public function __construct(
        private array $validators, // OK - using the injectable version
    )
}

#[InjectableVersion]
interface Logger {...}

class FileLogger implements Logger {...}

class MyService 
{
    #[CheckInjectableVersion]
    public function setLogger(Logger $logger): void {} // OK - Injectable Version injected
    
    public function addLogger(FileLogger $logger): void {} // No issue raised because addLogger doesn't have the #[CheckInjectableVersion] attribute.
}