Description:
------------
Currently there is no way to make a wrapper without using eval()

we see this in PHPUnit: https://github.com/sebastianbergmann/phpunit-mock-objects/blob/master/src/Framework/MockObject/Generator.php 

To generate a mock object PHPUnit has to generate the string

```
class NewClass extends OldClass {
   public function oldMethod() {
   }
   public function oldMethod() {
   }
}
```

and then use eval() to dynamically create this class. This takes a lot of effort and obviously is not a great solution.

It would be better, for this and other uses where a wrapper is useful (such as AOP) if this was possible:


```
class Wrapper {
   private $object;

   public function __construct($object) {
     $this->object = $object;
   }

   public function __call($func, $args) {
      $this->object->$func(...$args);
   }


   public function __set($name, $value) {
      $this->object->$name = $value;
   }

   public function __get($name) {
      return $this->object->$name;
   }

}

```

This will act as a wrapper for $object using `new Wrapper(new MyObj)` however this breaks, and the reason PHPUnit has to use `eval` is because the wrapper isn't actually an instance of the type being wrapped so this code fails:

```
function processObject(MyObj $obj) {

}
```

This works:

processObject(new MyObj);

but this does not:

processObject(new Wrapper(new MyObj));


It would be better if there was a way to make an object pretend to be another type. My suggestion is this:


```
```
class Wrapper {
   private $object;

   public function __construct($object) {
     $this->object = $object;
   }

   public function __call($func, $args) {
      $this->object->$func(...$args);
   }


   public function __set($name, $value) {
      $this->object->$name = $value;
   }

   public function __get($name) {
      return $this->object->$name;
   }


   public function __instanceof($name) {
      return $name == get_class($this->object;
   }
}


```

The __instanceof method would be called when an object is passed into a method with a type hint and the object is the wrong type. Rather than just erroring, the instanceof method is called with the type-hinted class name as an argument and the class can then pretend to be another class.

This may need to be an interface so that __call works.

There are several uses for this, an obvious one is PHPUnit's mock objects and another one would be being able to better implement Aspect Oriented Programming, something which needs the same workaround as PHPUnit currently.