Handle DurringCall magic methods

Author: akondas

extension.neon

@@ -2,6 +2,9 @@ services:
     -
         class: Proget\PHPStan\PhpSpec\Reflection\ObjectBehaviorMethodsClassReflectionExtension
         tags: [phpstan.broker.methodsClassReflectionExtension]
+    -
+        class: Proget\PHPStan\PhpSpec\Reflection\DuringCallMethodsClassReflectionExtension
+        tags: [phpstan.broker.methodsClassReflectionExtension]
     -
         class: Proget\PHPStan\PhpSpec\Reflection\ObjectBehaviorPropertiesClassReflectionExtension
         tags: [phpstan.broker.propertiesClassReflectionExtension]

spec/PhpSpec/CodeAnalysis/MagicAwareAccessInspectorSpec.php

@@ -26,7 +26,7 @@ public function it_should_detect_a_magic_getter_if_no_value_is_given()
 
     public function it_should_detect_a_magic_setter_if_a_value_is_given()
     {
-        $this->isPropertyWritable(new ObjectWithMagicSet, 'property', true)->shouldReturn(true);
+        $this->isPropertyWritable(new ObjectWithMagicSet, 'property')->shouldReturn(true);
     }
 
     public function it_should_detect_a_magic_call_method()

src/Reflection/DuringCallMethodsClassReflectionExtension.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Proget\PHPStan\PhpSpec\Reflection;
+
+use PHPStan\Analyser\OutOfClassScope;
+use PHPStan\Broker\Broker;
+use PHPStan\Reflection\BrokerAwareExtension;
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Reflection\MethodsClassReflectionExtension;
+use PhpSpec\Wrapper\Subject\Expectation\DuringCall;
+
+final class DuringCallMethodsClassReflectionExtension implements MethodsClassReflectionExtension, BrokerAwareExtension
+{
+    /**
+     * @var Broker
+     */
+    private $broker;
+
+    public function setBroker(Broker $broker): void
+    {
+        $this->broker = $broker;
+    }
+
+    public function hasMethod(ClassReflection $classReflection, string $methodName): bool
+    {
+        return $classReflection->getName() === DuringCall::class && preg_match('/^during(.+)$/', $methodName) !== false;
+    }
+
+    public function getMethod(ClassReflection $classReflection, string $methodName): MethodReflection
+    {
+        return new DuringMethodReflection($classReflection->getMethod('during', new OutOfClassScope()));
+    }
+}

src/Reflection/DuringMethodReflection.php

@@ -0,0 +1,72 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Proget\PHPStan\PhpSpec\Reflection;
+
+use PHPStan\Reflection\ClassMemberReflection;
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\Reflection\FunctionVariantWithPhpDocs;
+use PHPStan\Reflection\MethodReflection;
+
+final class DuringMethodReflection implements MethodReflection
+{
+    /**
+     * @var MethodReflection
+     */
+    private $during;
+
+    public function __construct(MethodReflection $during)
+    {
+        $this->during = $during;
+    }
+
+    public function getDeclaringClass(): ClassReflection
+    {
+        return $this->during->getDeclaringClass();
+    }
+
+    public function isStatic(): bool
+    {
+        return $this->during->isStatic();
+    }
+
+    public function isPrivate(): bool
+    {
+        return $this->during->isPrivate();
+    }
+
+    public function isPublic(): bool
+    {
+        return $this->during->isPublic();
+    }
+
+    public function getName(): string
+    {
+        return $this->during->getName();
+    }
+
+    public function getPrototype(): ClassMemberReflection
+    {
+        return $this->during->getPrototype();
+    }
+
+    public function getVariants(): array
+    {
+        $variants = $this->during->getVariants();
+        if (count($variants) === 1 && $variants[0] instanceof FunctionVariantWithPhpDocs) {
+            /** @var FunctionVariantWithPhpDocs $variant */
+            $variant = $variants[0];
+
+            return [new FunctionVariantWithPhpDocs(
+                [$variant->getParameters()[1]], //remove first param (see DuringCall::__call)
+                $variant->isVariadic(),
+                $variant->getReturnType(),
+                $variant->getPhpDocReturnType(),
+                $variant->getNativeReturnType()
+            )];
+        }
+
+        return $variants;
+    }
+}

src/Reflection/ObjectBehaviorMethodsClassReflectionExtension.php

@@ -57,6 +57,11 @@ public function getMethod(ClassReflection $classReflection, string $methodName):
             return $subjectReflection->getMethod($methodName, new OutOfClassScope());
         }
 
+        return $this->getWrappedClassMethodReflection($classReflection, $methodName);
+    }
+
+    private function getWrappedClassMethodReflection(ClassReflection $classReflection, $methodName): MethodReflection
+    {
         /** @var PSR0Resource[] $resources */
         $resources = $this->locator->findResources((string) $classReflection->getFileName());
 

src/Reflection/ObjectBehaviorPropertiesClassReflectionExtension.php

@@ -14,7 +14,9 @@
 use PHPStan\Reflection\ClassReflection;
 use PHPStan\Reflection\PropertiesClassReflectionExtension;
 use PHPStan\Reflection\PropertyReflection;
+use PHPStan\Type\MixedType;
 use Proget\PHPStan\PhpSpec\Exception\SpecSourceClassNotFound;
+use Proget\PHPStan\PhpSpec\Type\SubjectConstantPropertyReflection;
 
 final class ObjectBehaviorPropertiesClassReflectionExtension implements PropertiesClassReflectionExtension, BrokerAwareExtension
 {
@@ -64,7 +66,9 @@ public function getProperty(ClassReflection $classReflection, string $propertyNa
 
         //special case to handle magic proxy call in object behavior
         if ($srcClassReflection->hasConstant($propertyName)) {
-            throw new \RuntimeException('Need to implement this');
+            $constant = $srcClassReflection->getConstant($propertyName);
+
+            return new SubjectConstantPropertyReflection($constant->getDeclaringClass(), new MixedType());
         }
     }
 }

src/Type/SubjectConstantPropertyReflection.php

@@ -0,0 +1,64 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Proget\PHPStan\PhpSpec\Type;
+
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\Reflection\PropertyReflection;
+use PHPStan\Type\Type;
+
+final class SubjectConstantPropertyReflection implements PropertyReflection
+{
+    /**
+     * @var ClassReflection
+     */
+    private $declaringClass;
+
+    /**
+     * @var Type
+     */
+    private $type;
+
+    public function __construct(ClassReflection $declaringClass, Type $type)
+    {
+        $this->declaringClass = $declaringClass;
+        $this->type = $type;
+    }
+
+    public function getDeclaringClass(): ClassReflection
+    {
+        return $this->declaringClass;
+    }
+
+    public function isStatic(): bool
+    {
+        // although it could be argued, however, from the point of view of the spec, it is not static
+        return false;
+    }
+
+    public function isPrivate(): bool
+    {
+        return false;
+    }
+
+    public function isPublic(): bool
+    {
+        return true;
+    }
+
+    public function getType(): Type
+    {
+        return $this->type;
+    }
+
+    public function isReadable(): bool
+    {
+        return true;
+    }
+
+    public function isWritable(): bool
+    {
+        return false;
+    }
+}