fix: correct method reflection for magic with* calls on RedirectResponse

extension.neon

@@ -112,6 +112,10 @@ services:
         class: NunoMaduro\Larastan\Methods\ModelFactoryMethodsClassReflectionExtension
         tags:
             - phpstan.broker.methodsClassReflectionExtension
+    -
+        class: NunoMaduro\Larastan\Methods\RedirectResponseMethodsClassReflectionExtension
+        tags:
+            - phpstan.broker.methodsClassReflectionExtension
 
     -
         class: NunoMaduro\Larastan\Properties\ModelAccessorExtension

src/Methods/Kernel.php

@@ -60,7 +60,6 @@ public function handle(ClassReflection $classReflection, string $methodName): Pa
                     Pipes\Facades::class,
                     Pipes\Managers::class,
                     Pipes\Auths::class,
-                    Pipes\RedirectResponseWiths::class,
                 ]
             )
             ->then(

src/Methods/RedirectResponseMethodsClassReflectionExtension.php

@@ -0,0 +1,159 @@
+<?php
+
+namespace NunoMaduro\Larastan\Methods;
+
+use PHPStan\Reflection;
+use PHPStan\Reflection\FunctionVariant;
+use PHPStan\Reflection\ParameterReflection;
+use PHPStan\TrinaryLogic;
+use PHPStan\Type\Generic\TemplateTypeMap;
+use PHPStan\Type\MixedType;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
+
+class RedirectResponseMethodsClassReflectionExtension implements Reflection\MethodsClassReflectionExtension
+{
+    public function hasMethod(Reflection\ClassReflection $classReflection, string $methodName): bool
+    {
+        if ($classReflection->getName() !== 'Illuminate\Http\RedirectResponse') {
+            return false;
+        }
+
+        if (strpos($methodName, 'with') !== 0) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public function getMethod(
+        Reflection\ClassReflection $classReflection,
+        string $methodName
+    ): Reflection\MethodReflection {
+        return new class($classReflection, $methodName) implements Reflection\MethodReflection
+        {
+            /** @var Reflection\ClassReflection */
+            private $classReflection;
+
+            /** @var string */
+            private $methodName;
+
+            public function __construct(Reflection\ClassReflection $classReflection, string $methodName)
+            {
+                $this->classReflection = $classReflection;
+                $this->methodName = $methodName;
+            }
+
+            public function getDeclaringClass(): Reflection\ClassReflection
+            {
+                return $this->classReflection;
+            }
+
+            public function isStatic(): bool
+            {
+                return false;
+            }
+
+            public function isPrivate(): bool
+            {
+                return false;
+            }
+
+            public function isPublic(): bool
+            {
+                return true;
+            }
+
+            public function getDocComment(): ?string
+            {
+                return null;
+            }
+
+            public function getName(): string
+            {
+                return $this->methodName;
+            }
+
+            public function getPrototype(): Reflection\ClassMemberReflection
+            {
+                return $this;
+            }
+
+            public function getVariants(): array
+            {
+                return [
+                    new FunctionVariant(
+                        TemplateTypeMap::createEmpty(),
+                        TemplateTypeMap::createEmpty(),
+                        [
+                            new class implements ParameterReflection
+                            {
+                                public function getName(): string
+                                {
+                                    return 'dynamic-with';
+                                }
+
+                                public function isOptional(): bool
+                                {
+                                    return false;
+                                }
+
+                                public function getType(): \PHPStan\Type\Type
+                                {
+                                    return new MixedType();
+                                }
+
+                                public function passedByReference(): \PHPStan\Reflection\PassedByReference
+                                {
+                                    return Reflection\PassedByReference::createNo();
+                                }
+
+                                public function isVariadic(): bool
+                                {
+                                    return false;
+                                }
+
+                                public function getDefaultValue(): ?\PHPStan\Type\Type
+                                {
+                                    return null;
+                                }
+                            },
+                        ],
+                        false,
+                        new ObjectType($this->classReflection->getName())
+                    ),
+                ];
+            }
+
+            public function isDeprecated(): TrinaryLogic
+            {
+                return TrinaryLogic::createNo();
+            }
+
+            public function getDeprecatedDescription(): ?string
+            {
+                return null;
+            }
+
+            public function isFinal(): TrinaryLogic
+            {
+                return TrinaryLogic::createNo();
+            }
+
+            public function isInternal(): TrinaryLogic
+            {
+                return TrinaryLogic::createNo();
+            }
+
+            public function getThrowType(): ?Type
+            {
+                return null;
+            }
+
+            public function hasSideEffects(): TrinaryLogic
+            {
+                return TrinaryLogic::createNo();
+            }
+        };
+    }
+}

tests/Reflection/RedirectResponseMethodsClassReflectionExtensionTest.php

@@ -0,0 +1,96 @@
+<?php
+
+namespace Reflection;
+
+use Illuminate\Http\RedirectResponse;
+use NunoMaduro\Larastan\Methods\RedirectResponseMethodsClassReflectionExtension;
+use PHPStan\Reflection\ParametersAcceptorSelector;
+use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\Testing\PHPStanTestCase;
+use PHPStan\Type\VerbosityLevel;
+
+class RedirectResponseMethodsClassReflectionExtensionTest extends PHPStanTestCase
+{
+    /**
+     * @var ReflectionProvider
+     */
+    private $reflectionProvider;
+
+    /**
+     * @var RedirectResponseMethodsClassReflectionExtension
+     */
+    private $reflectionExtension;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->reflectionProvider = $this->createReflectionProvider();
+        $this->reflectionExtension = new RedirectResponseMethodsClassReflectionExtension();
+    }
+
+    /**
+     * @test
+     *
+     * @dataProvider greenMethodProvider
+     */
+    public function it_will_find_methods_starting_with_with(string $methodName)
+    {
+        $requestClass = $this->reflectionProvider->getClass(RedirectResponse::class);
+
+        $this->assertTrue($this->reflectionExtension->hasMethod($requestClass, $methodName));
+    }
+
+    /**
+     * @test
+     *
+     * @dataProvider redMethodProvider
+     */
+    public function it_will_not_find_methods(string $methodName)
+    {
+        $requestClass = $this->reflectionProvider->getClass(RedirectResponse::class);
+
+        $this->assertFalse($this->reflectionExtension->hasMethod($requestClass, $methodName));
+    }
+
+    /**
+     * @test
+     *
+     * @dataProvider greenMethodProvider
+     */
+    public function it_will_have_correct_method_reflection(string $methodName)
+    {
+        $requestClass = $this->reflectionProvider->getClass(RedirectResponse::class);
+        $methodReflection = $this->reflectionExtension->getMethod($requestClass, $methodName);
+        $parametersAcceptor = ParametersAcceptorSelector::selectSingle($methodReflection->getVariants());
+
+        $this->assertSame($methodName, $methodReflection->getName());
+        $this->assertSame($requestClass, $methodReflection->getDeclaringClass());
+        $this->assertFalse($methodReflection->isStatic());
+        $this->assertFalse($methodReflection->isPrivate());
+        $this->assertTrue($methodReflection->isPublic());
+        $this->assertCount(1, $parametersAcceptor->getParameters());
+        $this->assertSame('mixed', $parametersAcceptor->getParameters()[0]->getType()->describe(VerbosityLevel::value()));
+        $this->assertSame(RedirectResponse::class, $parametersAcceptor->getReturnType()->describe(VerbosityLevel::value()));
+    }
+
+    /** @return iterable<mixed> */
+    public function greenMethodProvider(): iterable
+    {
+        yield ['withFoo'];
+        yield ['withFooAndBar'];
+    }
+
+    /** @return iterable<mixed> */
+    public function redMethodProvider(): iterable
+    {
+        yield ['non-existent'];
+        yield ['aWith'];
+        yield ['WithFoo'];
+    }
+
+    public static function getAdditionalConfigFiles(): array
+    {
+        return [__DIR__.'/../../extension.neon'];
+    }
+}

tests/Type/MethodsClassReflectionExtensionTest.php

@@ -10,6 +10,7 @@ class MethodsClassReflectionExtensionTest extends \PHPStan\Testing\TypeInference
     public function dataFileAsserts(): iterable
     {
         yield from $this->gatherAssertTypes(__DIR__.'/data/macros.php');
+        yield from $this->gatherAssertTypes(__DIR__.'/data/redirect-response.php');
     }
 
     /**

tests/Type/data/redirect-response.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace RedirectResponse;
+
+use Illuminate\Http\RedirectResponse;
+use function PHPStan\Testing\assertType;
+
+assertType(RedirectResponse::class, redirect()->back()->withSuccess(true));
+assertType(RedirectResponse::class, redirect()->back()->withCookie('foo'));