Merge branch '3.x' into dependabot/composer/doctrine/annotations-tw-1…

….11.1or-tw-2.0.0

composer.json

@@ -9,7 +9,7 @@
 
     "require": {
         "php": "^7.4.0",
-        "doctrine/annotations": "^1.11.1 || ^2.0.0",
+        "doctrine/annotations": "^2.0",
         "doctrine/cache": "^1.10",
         "goaop/parser-reflection": "^3.0.1",
         "jakubledl/dissect": "~1.0",
@@ -54,7 +54,8 @@
             "Go\\Tests\\TestProject\\": "tests/Fixtures/project/src/"
         },
         "files": [
-            "tests/functions.php"
+            "tests/functions.php",
+            "tests/Go/Stubs/ClassWithoutNamespace.php"
         ]
     },
 

src/Aop/Framework/AbstractInterceptor.php

@@ -65,7 +65,7 @@ abstract class AbstractInterceptor implements Interceptor, OrderedAdvice, Serial
     /**
      * Advice order
      */
-    private int $adviceOrder;
+    private int $adviceOrder = 0;
 
     /**
      * Default constructor for interceptor

src/Aop/Framework/AbstractMethodInvocation.php

@@ -27,7 +27,7 @@ abstract class AbstractMethodInvocation extends AbstractInvocation implements Me
     /**
      * Instance of object for invoking
      */
-    protected ?object $instance;
+    protected ?object $instance = null;
 
     /**
      * Instance of reflection method for invocation

src/Core/GoAspectContainer.php

@@ -13,7 +13,7 @@
 namespace Go\Core;
 
 use Doctrine\Common\Annotations\AnnotationReader;
-use Doctrine\Common\Annotations\CachedReader;
+use Doctrine\Common\Annotations\PsrCachedReader;
 use Doctrine\Common\Cache as DoctrineCache;
 use Go\Aop\Advisor;
 use Go\Aop\Aspect;
@@ -104,10 +104,11 @@ public function __construct()
 
         $this->share('aspect.annotation.reader', function (Container $container) {
             $options = $container->get('kernel.options');
+            $annotationCache = $container->get('aspect.annotation.cache');
 
-            return new CachedReader(
+            return new PsrCachedReader(
                 new AnnotationReader(),
-                $container->get('aspect.annotation.cache'),
+                new DoctrineCache\Psr6\CacheAdapter($annotationCache),
                 $options['debug'] ?? false
             );
         });

src/Instrument/ClassLoading/AopComposerLoader.php

@@ -18,7 +18,6 @@
 use Go\Instrument\PathResolver;
 use Go\Instrument\Transformer\FilterInjectorTransformer;
 use Composer\Autoload\ClassLoader;
-use Doctrine\Common\Annotations\AnnotationRegistry;
 
 /**
  * AopComposerLoader class is responsible to use a weaver for classes instead of original one
@@ -92,13 +91,6 @@ public static function init(array $options, AspectContainer $container): bool
         foreach ($loaders as &$loader) {
             $loaderToUnregister = $loader;
             if (is_array($loader) && ($loader[0] instanceof ClassLoader)) {
-                $originalLoader = $loader[0];
-                // Configure library loader for doctrine annotation loader
-                AnnotationRegistry::registerLoader(function($class) use ($originalLoader) {
-                    $originalLoader->loadClass($class);
-
-                    return class_exists($class, false);
-                });
                 $loader[0] = new AopComposerLoader($loader[0], $container, $options);
                 self::$wasInitialized = true;
             }

src/Instrument/Transformer/SelfValueVisitor.php

@@ -81,7 +81,7 @@ public function beforeTraverse(array $nodes)
     public function enterNode(Node $node)
     {
         if ($node instanceof Namespace_) {
-            $this->namespace = $node->name->toString();
+            $this->namespace = !empty($node->name) ? $node->name->toString() : null;
         } elseif ($node instanceof Class_) {
             if ($node->name !== null) {
                 $this->className = new Name($node->name->toString());

src/Proxy/ClassProxyGenerator.php

@@ -109,7 +109,7 @@ public function __construct(
 
         $this->generator = new ClassGenerator(
             $originalClass->getShortName(),
-            $originalClass->getNamespaceName(),
+            !empty($originalClass->getNamespaceName()) ? $originalClass->getNamespaceName() : null,
             $originalClass->isFinal() ? ClassGenerator::FLAG_FINAL : null,
             $parentClassName,
             $introducedInterfaces,

src/Proxy/Part/InterceptedMethodGenerator.php

@@ -39,7 +39,7 @@ public function __construct(ReflectionMethod $reflectionMethod, string $body, bo
         if ($reflectionMethod->hasReturnType()) {
             $reflectionReturnType = $reflectionMethod->getReturnType();
             if ($reflectionReturnType instanceof ReflectionNamedType) {
-                $returnTypeName = $reflectionReturnType->getName();
+                $returnTypeName = ($reflectionReturnType->allowsNull() ? '?' : '') . $reflectionReturnType->getName();
             } else {
                 $returnTypeName = (string)$reflectionReturnType;
             }

tests/Go/Aop/Framework/AbstractMethodInvocationTest.php

@@ -29,4 +29,41 @@ public function testProvidesAccessToAnnotations(): void
     {
         $this->assertInstanceOf(AnnotationAccess::class, $this->invocation->getMethod());
     }
+
+    public function testInstanceIsInitialized(): void
+    {
+        $this->expectNotToPerformAssertions();
+        $o = new class extends AbstractMethodInvocation {
+
+            protected static string $propertyName = 'scope';
+            public function __construct()
+            {
+                parent::__construct([new AroundInterceptor(function () {})], '\Go\Aop\Framework\AbstractMethodInvocationTest', 'testInstanceIsInitialized');
+            }
+
+            public function isDynamic(): bool
+            {
+                return false;
+            }
+
+            public function getThis(): ?object
+            {
+                return null;
+            }
+
+            public function getScope(): string
+            {
+                return 'testScope';
+            }
+
+            public function proceed()
+            {
+                if ($this->level < 3) {
+                    $this->__invoke('testInstance');
+                }
+            }
+        };
+
+        $o->__invoke('testInstance');
+    }
 }

tests/Go/Instrument/Transformer/SelfValueTransformerTest.php

@@ -72,4 +72,14 @@ public function testTransformerReplacesAllSelfPlaces(): void
         $expected = file_get_contents(__DIR__ . '/_files/file-with-self-transformed.php');
         $this->assertSame($expected, (string) $metadata->source);
     }
+
+    public function testTransformerReplacesAllSelfPlacesWithoutNamespace(): void
+    {
+        $testFile = fopen(__DIR__ . '/_files/file-with-self-no-namespace.php', 'rb');
+        $content  = stream_get_contents($testFile);
+        $metadata = new StreamMetaData($testFile, $content);
+        $this->transformer->transform($metadata);
+        $expected = file_get_contents(__DIR__ . '/_files/file-with-self-no-namespace-transformed.php');
+        $this->assertSame($expected, (string) $metadata->source);
+    }
 }

tests/Go/Instrument/Transformer/_files/file-with-self-no-namespace-transformed.php

@@ -0,0 +1,61 @@
+<?php
+/** @noinspection PhpIllegalPsrClassPathInspection */
+declare(strict_types=1);
+
+class ClassWithSelfNoNamespace extends \Exception
+{
+    const CLASS_CONST = \ClassWithSelfNoNamespace::class;
+
+    private static $foo = 42;
+
+    private \ClassWithSelfNoNamespace $instance;
+
+    public function acceptsAndReturnsSelf(\ClassWithSelfNoNamespace $instance): \ClassWithSelfNoNamespace
+    {
+        return $instance;
+    }
+
+    public function containsClosureWithSelf()
+    {
+        $func = function (\ClassWithSelfNoNamespace $instance): \ClassWithSelfNoNamespace {
+            return $instance;
+        };
+        $func($this);
+    }
+
+    public function staticMethodCall()
+    {
+        return \ClassWithSelfNoNamespace::staticPropertyAccess();
+    }
+
+    public function classConstantFetch()
+    {
+        return \ClassWithSelfNoNamespace::class . \ClassWithSelfNoNamespace::CLASS_CONST;
+    }
+
+    public static function staticPropertyAccess()
+    {
+        return self::$foo;
+    }
+
+    public function newInstanceCreation()
+    {
+        return new \ClassWithSelfNoNamespace;
+    }
+
+    public function catchSection()
+    {
+        try {
+            throw new \ClassWithSelfNoNamespace;
+        } catch (\ClassWithSelfNoNamespace $exception) {
+            // Nop
+        }
+    }
+
+    public function instanceCheck()
+    {
+        if ($this instanceof \ClassWithSelfNoNamespace) {
+            // Nop
+        }
+    }
+}

tests/Go/Instrument/Transformer/_files/file-with-self-no-namespace.php

@@ -0,0 +1,61 @@
+<?php
+/** @noinspection PhpIllegalPsrClassPathInspection */
+declare(strict_types=1);
+
+class ClassWithSelfNoNamespace extends \Exception
+{
+    const CLASS_CONST = self::class;
+
+    private static $foo = 42;
+
+    private self $instance;
+
+    public function acceptsAndReturnsSelf(self $instance): self
+    {
+        return $instance;
+    }
+
+    public function containsClosureWithSelf()
+    {
+        $func = function (self $instance): self {
+            return $instance;
+        };
+        $func($this);
+    }
+
+    public function staticMethodCall()
+    {
+        return self::staticPropertyAccess();
+    }
+
+    public function classConstantFetch()
+    {
+        return self::class . self::CLASS_CONST;
+    }
+
+    public static function staticPropertyAccess()
+    {
+        return self::$foo;
+    }
+
+    public function newInstanceCreation()
+    {
+        return new self;
+    }
+
+    public function catchSection()
+    {
+        try {
+            throw new self;
+        } catch (self $exception) {
+            // Nop
+        }
+    }
+
+    public function instanceCheck()
+    {
+        if ($this instanceof self) {
+            // Nop
+        }
+    }
+}

tests/Go/Proxy/ClassProxyGeneratorTest.php

@@ -93,6 +93,7 @@ public function dataGenerator(): array
             [First::class, 'publicMethod'],
             [First::class, 'protectedMethod'],
             [First::class, 'passByReference'],
+            [\ClassWithoutNamespace::class, 'publicMethod'],
         ];
     }
 }

tests/Go/Stubs/ClassWithoutNamespace.php

@@ -0,0 +1,11 @@
+<?php /** @noinspection PhpIllegalPsrClassPathInspection */
+
+
+class ClassWithoutNamespace
+{
+    public function publicMethod(): int
+    {
+        return 1;
+    }
+
+}