use Ray\Aop\AbstractMatcher;

class MyMatcher extends AbstractMatcher
{
    /**
     * @param $contain
     *
     * @return MyMatcher
     */
    public function contains($contain)
    {
        $this->createMatcher(__FUNCTION__, $contain);

        return clone $this;

    }

    /**
     * Return isContains
     *
     * @param $name    class or method name
     * @param $target  \Ray\Aop\AbstractMatcher::TARGET_CLASS | \Ray\Aop\AbstractMatcher::Target_METHOD
     * @param $contain
     *
     * @return bool
     */
    protected function isContains($name, $target, $contain)
    {
        $result = (strpos($name, $contain) !== false);

        return $result;
    }
}

class MetaCrawlerService extends CrawlerService

class MetaCrawlerService_KGlnUTY extends MetaCrawlerService implements WeavedInterface

abstract class CrawlerService_NXUWZ0A extends CrawlerService implements WeavedInterface

        if (!$this->isAspect) {
            $this->isAspect = true;
            call_user_func_array([$this, 'parent::' . __FUNCTION__], func_get_args());
            return;
        }

        if (!$this->isAspect) {
            $this->isAspect = true;

            $class = (new \ReflectionObject($this))->getParentClass();

            $rc1 = new \ReflectionClass($class->name);

            do {
                $method = new \ReflectionMethod($rc1->getParentClass()->name, __FUNCTION__);
                $rc1 = new \ReflectionClass($method->class);
            } while($rc1->implementsInterface(WeavedInterface::class) );

            $method = new \ReflectionMethod($rc1->name, __FUNCTION__);
            $method->invokeArgs($this, func_get_args());
            
            return;
        }

<?php

declare (strict_types=1);
namespace Ray\Aop\Demo;

use Ray\Aop\WeavedInterface;
use Ray\Aop\ReflectiveMethodInvocation as Invocation;
class AnnotationRealBillingService_NXhGYhg extends \Ray\Aop\Demo\AnnotationRealBillingService implements BillingService, WeavedInterface
{
    public $bind;
    public $bindings = [];
    public $methodAnnotations = 'a:1:{s:11:"chargeOrder";a:1:{i:0;O:25:"Ray\\Aop\\Demo\\WeekendBlock":0:{}}}';
    public $classAnnotations = 'a:0:{}';
    private $isAspect = true;
    /**
     * @WeekendBlock
     */
    public function chargeOrder() : void
    {
        if (!$this->isAspect) {
            $this->isAspect = true;
            return call_user_func_array([$this, 'parent::' . __FUNCTION__], func_get_args());
        }
        $this->isAspect = false;
        $result = (new Invocation($this, __FUNCTION__, func_get_args(), $this->bindings[__FUNCTION__]))->proceed();
        $this->isAspect = true;
        return $result;
    }
}

    public function chargeOrder() : void
    {
        ...
        return $result;  // ouch!
    }

class FakeMock_358616026 extends \Ray\Aop\FakeMock implements WeavedInterface
{
    public $bind;
    public $bindings = [];
    public $methodAnnotations = 'a:0:{}';
    public $classAnnotations = 'a:0:{}';
    public $isAspect = true;
    /**
     * doc comment of returnSame
     */
    public function returnSame($a)
    {
        if (!$this->isAspect) {
            $this->isAspect = true;
            return call_user_func_array([parent::class, __FUNCTION__], func_get_args());
        }
        $this->isAspect = false;
        $result = (new Invocation($this, __FUNCTION__, func_get_args(), $this->bindings[__FUNCTION__]))->proceed();
        $this->isAspect = true;
        return $result;
    }
}

class FakeMock_358616026 extends \Ray\Aop\FakeMock implements WeavedInterface
{
    use AopTrait;

    /**
     * doc comment of returnSame
     */
    public function returnSame($a)
    {
        return $this->__aop(func_get_args(), __FUNCTION__);
    }
}

<?php

namespace Ray\Aop;

use Ray\Aop\ReflectiveMethodInvocation as Invocation;
use function call_user_func_array;
use function func_get_args;

trait AopTrait
{
    private $bind;
    private $bindings = [];
    public $methodAnnotations = 'a:0:{}';
    public $classAnnotations = 'a:0:{}';
    private $isAspect = true;

    private function __aop(array $args, string $func)
    {
        if (!$this->isAspect) {
            $this->isAspect = true;
            return call_user_func_array([parent::class, __FUNCTION__], func_get_args());
        }
        $this->isAspect = false;
        $result = (new Invocation($this, __FUNCTION__, func_get_args(), $this->bindings[__FUNCTION__]))->proceed();
        $this->isAspect = true;
        return $result;
    }
}

<?php
declare(strict_types=1);

namespace Ray\Aop\Demo;

use ArrayIterator;
use Traversable;

class A
{
    public function passIterator(ArrayIterator $iterator): Traversable
    {
        return $iterator;
    }
}

<?php
declare(strict_types=1);

namespace Ray\Aop\Demo;

class B extends A
{
}

<?php

use Ray\Aop\NullInterceptor;

require __DIR__ . '/bootstrap.php';

$compiler = new Ray\Aop\Compiler(__DIR__ . '/tmp');
$bind = (new Ray\Aop\Bind())->bindInterceptors('passIterator', [new NullInterceptor()]);
$b = $compiler->newInstance(Ray\Aop\Demo\B::class, [], $bind);
$b->passIterator(new ArrayIterator());

<?php

declare (strict_types=1);
namespace Ray\Aop\Demo;

use Ray\Aop\WeavedInterface;
use Ray\Aop\ReflectiveMethodInvocation as Invocation;
class B_3617677882 extends \Ray\Aop\Demo\B implements WeavedInterface
{
    public $bind;
    public $bindings = [];
    public $methodAnnotations = 'a:0:{}';
    public $classAnnotations = 'a:0:{}';
    private $isAspect = true;
    public function passIterator(ArrayIterator $iterator) : Traversable
    {
        if (!$this->isAspect) {
            $this->isAspect = true;
            return call_user_func_array([$this, 'parent::' . __FUNCTION__], func_get_args());
        }
        $this->isAspect = false;
        $result = (new Invocation($this, __FUNCTION__, func_get_args(), $this->bindings[__FUNCTION__]))->proceed();
        $this->isAspect = true;
        return $result;
    }
}

<?php

use Doctrine\Common\Annotations\CachedReader;
use Doctrine\Common\Annotations\AnnotationReader;
use Doctrine\Common\Cache\ApcCache;

$reader = new CachedReader(new AnnotationReader(new ApcCache));
Matcher::setAnnotationReader($reader);

public function startsWith($prefix);

public function startWith($prefix);

class FakeAnonymousClass
{
    public function hasAnonymousClass($a): object
    {
        return new class {};
    }
}

$instance = $compiler->noBindNewInstance($definition->class, $params, $bind);
$hasBinding = $bind->hasBinding();

// setter injection here
// ....

 // attach interceptors
if ($hasBinding) {
    $instance->rayAopBind = $bind;
}

        if (class_exists($aopClassName, false)) {