diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/arrow_function.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/arrow_function.php.inc
new file mode 100644
index 00000000000..1e02f85474c
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/arrow_function.php.inc
@@ -0,0 +1,25 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+$simple = fn($x): string|int|bool => $x > 5 ? 'high' : 10;
+
+$ternary = fn($value): string|int|float|null =>
+    $value === null ? null : ($value > 0 ? 'positive' : -1);
+
+$cast = fn($input): int|string|array => (int) $input;
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+$simple = fn($x): string|int => $x > 5 ? 'high' : 10;
+
+$ternary = fn($value): string|int|null =>
+    $value === null ? null : ($value > 0 ? 'positive' : -1);
+
+$cast = fn($input): int => (int) $input;
+
+?>
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/closure.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/closure.php.inc
new file mode 100644
index 00000000000..1380d360f1e
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/closure.php.inc
@@ -0,0 +1,35 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+$callback = function(): string|int|array|null {
+    if (rand(0, 1)) {
+        return 'result';
+    }
+
+    if (rand(0, 1)) {
+        return 42;
+    }
+
+    return null;
+};
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+$callback = function(): string|int|null {
+    if (rand(0, 1)) {
+        return 'result';
+    }
+
+    if (rand(0, 1)) {
+        return 42;
+    }
+
+    return null;
+};
+
+?>
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/edge_cases.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/edge_cases.php.inc
new file mode 100644
index 00000000000..d0ba4dad7c7
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/edge_cases.php.inc
@@ -0,0 +1,59 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+final class EdgeCases
+{
+    public function implicitNull(): string|int|null
+    {
+        if (rand(0, 1)) {
+            return;
+        }
+
+        return 'something';
+    }
+
+    public function implicitReturn(): string|int|null
+    {
+        if (rand(0, 1)) {
+            return 'something';
+        }
+    }
+
+    public function nullableReturn(): ?string
+    {
+        return 'something';
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+final class EdgeCases
+{
+    public function implicitNull(): ?string
+    {
+        if (rand(0, 1)) {
+            return;
+        }
+
+        return 'something';
+    }
+
+    public function implicitReturn(): ?string
+    {
+        if (rand(0, 1)) {
+            return 'something';
+        }
+    }
+
+    public function nullableReturn(): string
+    {
+        return 'something';
+    }
+}
+
+?>
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/final_class.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/final_class.php.inc
new file mode 100644
index 00000000000..f74634b803f
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/final_class.php.inc
@@ -0,0 +1,87 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+final class FinalClass
+{
+    public function getData(): string|int|\DateTime
+    {
+        if (rand(0, 1)) {
+            return 'text';
+        }
+
+        if (rand(0, 1)) {
+            return 'text';
+        }
+
+        return 1000;
+    }
+
+    public function getInfo(): string|int|bool|null
+    {
+        if (rand(0, 1)) {
+            return 'info';
+        }
+
+        if (rand(0, 1)) {
+            return null;
+        }
+
+        return 42;
+    }
+
+    private function processData(): string|array|object
+    {
+        if (rand(0, 1)) {
+            return 'processed';
+        }
+
+        return ['data' => 'value'];
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+final class FinalClass
+{
+    public function getData(): int|string
+    {
+        if (rand(0, 1)) {
+            return 'text';
+        }
+
+        if (rand(0, 1)) {
+            return 'text';
+        }
+
+        return 1000;
+    }
+
+    public function getInfo(): string|int|null
+    {
+        if (rand(0, 1)) {
+            return 'info';
+        }
+
+        if (rand(0, 1)) {
+            return null;
+        }
+
+        return 42;
+    }
+
+    private function processData(): string|array
+    {
+        if (rand(0, 1)) {
+            return 'processed';
+        }
+
+        return ['data' => 'value'];
+    }
+}
+
+?>
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/final_inheritance.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/final_inheritance.php.inc
new file mode 100644
index 00000000000..e1f81c5f4e2
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/final_inheritance.php.inc
@@ -0,0 +1,59 @@
+<?php
+
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+use Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Source\SomeInterface;
+use Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Sourcet\SomeAbstractClass;
+
+final class FinalInheritance extends SomeAbstractClass
+{
+    public function process(): string|int|array
+    {
+        if (rand(0, 1)) {
+            return 'text';
+        }
+
+        return 42;
+    }
+}
+
+final class FinalInterfaceImplementation implements SomeInterface
+{
+    public function getData(): string|int|bool
+    {
+        return 'data';
+    }
+}
+
+?>
+-----
+<?php
+
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+use Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Source\SomeInterface;
+use Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Sourcet\SomeAbstractClass;
+
+final class FinalInheritance extends SomeAbstractClass
+{
+    public function process(): string|int
+    {
+        if (rand(0, 1)) {
+            return 'text';
+        }
+
+        return 42;
+    }
+}
+
+final class FinalInterfaceImplementation implements SomeInterface
+{
+    public function getData(): string
+    {
+        return 'data';
+    }
+}
+
+?>
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/final_methods.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/final_methods.php.inc
new file mode 100644
index 00000000000..938c6f8429a
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/final_methods.php.inc
@@ -0,0 +1,57 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+class NonFinalClassWithFinalMethods
+{
+    public function getData(): string|int|\DateTime
+    {
+        return 'hello';
+    }
+
+    final public function getInfo(): string|int|bool
+    {
+        return 'info';
+    }
+
+    final protected function processData(): string|array|object
+    {
+        return 'processed';
+    }
+
+    private function helper(): string|int|float
+    {
+        return 'helper';
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+class NonFinalClassWithFinalMethods
+{
+    public function getData(): string|int|\DateTime
+    {
+        return 'hello';
+    }
+
+    final public function getInfo(): string
+    {
+        return 'info';
+    }
+
+    final protected function processData(): string
+    {
+        return 'processed';
+    }
+
+    private function helper(): string
+    {
+        return 'helper';
+    }
+}
+
+?>
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/function.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/function.php.inc
new file mode 100644
index 00000000000..a2caaafb334
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/function.php.inc
@@ -0,0 +1,37 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+function processValue(): string|int|float|bool
+{
+    if (rand(0, 1)) {
+        return 'text';
+    }
+
+    if (rand(0, 1)) {
+        return 123;
+    }
+
+    return true;
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+function processValue(): string|int|bool
+{
+    if (rand(0, 1)) {
+        return 'text';
+    }
+
+    if (rand(0, 1)) {
+        return 123;
+    }
+
+    return true;
+}
+
+?>
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/phpdocs.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/phpdocs.php.inc
new file mode 100644
index 00000000000..40d92c06dd3
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/phpdocs.php.inc
@@ -0,0 +1,129 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+use Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Source\SomeInterface;
+
+final class PhpDocs
+{
+    /** @return string|int|float */
+    public function foo(): string|int|float
+    {
+        if (rand(0, 1)) {
+            return 'text';
+        }
+
+        return 1000;
+    }
+
+    /**
+     * @param class-string<SomeInterface> $class
+     * @return class-string<SomeInterface>|int
+     */
+    public function bar(string $class): string|int
+    {
+        return $class;
+    }
+
+    /** @return class-string<SomeInterface>|int */
+    public function baz(string $class): string|int
+    {
+        return SomeInterface::class;
+    }
+
+    /** @return \Iterator<int, int>|string */
+    function qux(): \Iterator|string
+    {
+       return new \ArrayIterator([1]);
+    }
+
+    /** @return \Iterator<int, int>|string */
+    function qax(): \Iterator|string
+    {
+       return 'text';
+    }
+
+    /**
+     * @param int $a
+     */
+    function quux(int $a): int|string
+    {
+        return $a;
+    }
+
+    /**
+     * @param int $a
+     * @return int|string
+     */
+    function mixedReturn(int $a): int|string
+    {
+        return $a;
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+use Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Source\SomeInterface;
+
+final class PhpDocs
+{
+    /** @return int|string */
+    public function foo(): string|int
+    {
+        if (rand(0, 1)) {
+            return 'text';
+        }
+
+        return 1000;
+    }
+
+    /**
+     * @param class-string<SomeInterface> $class
+     * @return class-string<Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Source\SomeInterface>
+     */
+    public function bar(string $class): string
+    {
+        return $class;
+    }
+
+    /** @return class-string<Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Source\SomeInterface> */
+    public function baz(string $class): string
+    {
+        return SomeInterface::class;
+    }
+
+    /** @return \Iterator<int, int> */
+    function qux(): \Iterator
+    {
+       return new \ArrayIterator([1]);
+    }
+
+    /** @return string */
+    function qax(): string
+    {
+       return 'text';
+    }
+
+    /**
+     * @param int $a
+     */
+    function quux(int $a): int
+    {
+        return $a;
+    }
+
+    /**
+     * @param int $a
+     * @return int
+     */
+    function mixedReturn(int $a): int
+    {
+        return $a;
+    }
+}
+
+?>
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_abstracts.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_abstracts.php.inc
new file mode 100644
index 00000000000..4c218f4c0cc
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_abstracts.php.inc
@@ -0,0 +1,28 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+abstract class SkipAbstractClass
+{
+    abstract public function process(): string|int|array;
+
+    public function getData(): string|int|bool
+    {
+        return 'data';
+    }
+}
+
+interface SkipInterface
+{
+    public function handle(): string|int|null;
+}
+
+trait SkipTrait
+{
+    public function process(): string|array|null
+    {
+        return 'processed';
+    }
+}
+
+?>
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_constant_wildcard.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_constant_wildcard.php.inc
new file mode 100644
index 00000000000..48816681ff8
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_constant_wildcard.php.inc
@@ -0,0 +1,24 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+use OndraM\CiDetector\CiDetector;
+
+final class SkipConstantWildcard
+{
+    /**
+     * @return CiDetector::CI_*|bool|null
+     */
+    public function resolveCurrentCI(): string|bool|null
+    {
+        if (file_exists(getcwd() . '/.github/workflows/ci.yml')) {
+            return CiDetector::CI_GITHUB_ACTIONS;
+        }
+
+        if (file_exists(getcwd() . '/.gitlab-ci.yml')) {
+            return CiDetector::CI_GITLAB;
+        }
+
+        return null;
+    }
+}
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_docblock_call_on_arrow_function.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_docblock_call_on_arrow_function.php.inc
new file mode 100644
index 00000000000..d72e6f704e6
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_docblock_call_on_arrow_function.php.inc
@@ -0,0 +1,21 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+final class SkipDocblockCallOnArrowFunction
+{
+    public function run()
+    {
+        fn (): string|int => $this->execute();
+    }
+
+    /**
+     * @return string
+     */
+    private function execute()
+    {
+        return 1;
+    }
+}
+
+?>
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_exact_types.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_exact_types.php.inc
new file mode 100644
index 00000000000..348f112ecf2
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_exact_types.php.inc
@@ -0,0 +1,26 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+final class ExactTypes
+{
+    /**
+     * @return 'Gitlab'|'GitHub'|bool|int|null
+     */
+    public function foodd(): string|bool|int|null
+    {
+        if (! $__ENV['CI']) {
+            return false;
+        }
+
+        if (file_exists(getcwd() . '/.gitlab-ci.yml')) {
+            return 'Gitlab';
+        }
+
+        if (file_exists(getcwd() . '/.github/workflows')) {
+            return 'GitHub';
+        }
+
+        return null;
+    }
+}
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_generator.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_generator.php.inc
new file mode 100644
index 00000000000..543ca973c86
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_generator.php.inc
@@ -0,0 +1,63 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+class SkipGenerator
+{
+    public function generate(): \Generator|array|null
+    {
+        if (rand(0, 1)) {
+            yield 1;
+            yield 2;
+        }
+
+        return 'test';
+    }
+
+    public function delegate(): \Generator|array
+    {
+        yield from [1, 2, 3];
+    }
+}
+
+function generate(): \Generator|array|null
+{
+    if (rand(0, 1)) {
+        yield 1;
+        yield 2;
+    }
+
+    return 'test';
+}
+
+function delegate(): \Generator|array
+{
+    yield from [1, 2, 3];
+}
+
+function(): \Generator|array|null
+{
+    if (rand(0, 1)) {
+        yield 1;
+        yield 2;
+    }
+
+    return 'test';
+};
+
+function(): \Generator|array|null
+{
+    yield from [1, 2, 3];
+};
+
+fn(): \Iterator|array|null => yield 1;
+
+fn(string $a): \Iterator|array|null => match ($a) {
+    'a' => yield 1,
+    'b' => yield 2,
+    default => 'test',
+};
+
+fn(): \Iterator|array|null => yield from [1, 2, 3];
+
+?>
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_native_mixed_returns.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_native_mixed_returns.php.inc
new file mode 100644
index 00000000000..f26e65d9907
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_native_mixed_returns.php.inc
@@ -0,0 +1,29 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+final class SkipFunctionLikesWithoutParameterTypes
+{
+    /**
+     * @param class-string<SomeInterface> $class
+     * @return class-string<SomeInterface>|int
+     */
+    public function bar($class): string|int
+    {
+        return $class;
+    }
+
+    /**
+     * @return class-string<\stdClass>|int
+     */
+    public function skipMixedByDoc(): string|int
+    {
+        /**
+         * @var class-string<\stdClass> $class
+         */
+        $class = get();
+        return $class;
+    }
+}
+
+?>
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_non_final_classes.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_non_final_classes.php.inc
new file mode 100644
index 00000000000..df43fc5a948
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_non_final_classes.php.inc
@@ -0,0 +1,18 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+class SkipNonFinalClass
+{
+    public function getData(): string|int|\DateTime
+    {
+        return 'hello';
+    }
+
+    protected function getInfo(): string|int|bool
+    {
+        return 'info';
+    }
+}
+
+?>
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_non_final_inheritance.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_non_final_inheritance.php.inc
new file mode 100644
index 00000000000..d0c024cd6bb
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_non_final_inheritance.php.inc
@@ -0,0 +1,29 @@
+<?php
+
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+use Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Source\SomeInterface;
+use Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Sourcet\SomeAbstractClass;
+
+class SkipInheritance extends SomeAbstractClass
+{
+    public function process(): string|int|array
+    {
+        if (rand(0, 1)) {
+            return 'text';
+        }
+
+        return 42;
+    }
+}
+
+class SkipInterfaceImplementation implements SomeInterface
+{
+    public function getData(): string|int|bool
+    {
+        return 'data';
+    }
+}
+
+?>
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_null.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_null.php.inc
new file mode 100644
index 00000000000..112b658ac46
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_null.php.inc
@@ -0,0 +1,11 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+final class SkipNull
+{
+    public function run(): ?string
+    {
+        return null;
+    }
+}
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_parent_and_child_combine.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_parent_and_child_combine.php.inc
new file mode 100644
index 00000000000..3796b2286fa
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_parent_and_child_combine.php.inc
@@ -0,0 +1,13 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+final class SkipParentAndChildCombine
+{
+    public function run(): \DateTimeInterface|\DateTimeImmutable
+    {
+        return rand(0, 1)
+            ? new \DateTime('now')
+            : new \DateTimeImmutable('now');
+    }
+}
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_return_all_types.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_return_all_types.php.inc
new file mode 100644
index 00000000000..04b9d6f1893
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_return_all_types.php.inc
@@ -0,0 +1,45 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+final class SkipReturnAllTypes
+{
+    public function getData(): string|int|float
+    {
+        if (rand(0, 1)) {
+            return 'text';
+        }
+
+        if (rand(0, 1)) {
+            return 0.42;
+        }
+
+        return 1000;
+    }
+
+    public function implicitReturn(): string|null
+    {
+        if (rand(0, 1)) {
+            return 'something';
+        }
+    }
+
+    function foo(): int|null
+    {
+        if (rand(0, 1)) {
+             return 1;
+        }
+
+        if (rand(0, 1)) {
+             return 2;
+        }
+
+        if (rand(0, 1)) {
+             return 3;
+        }
+
+        return null;
+    }
+}
+
+?>
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_standalone_null.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_standalone_null.php.inc
new file mode 100644
index 00000000000..572d0a93992
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_standalone_null.php.inc
@@ -0,0 +1,18 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+final class SkipStandaloneNull
+{
+    public function foo(): ?string
+    {
+        return null;
+    }
+
+    public function foo(): string|null
+    {
+        return null;
+    }
+}
+
+?>
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_true_false_to_become_bool.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_true_false_to_become_bool.php.inc
new file mode 100644
index 00000000000..82bdf954a29
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_true_false_to_become_bool.php.inc
@@ -0,0 +1,16 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+final class SkipTrueFalseToBecomeBool
+{
+    public function run(): false|string
+    {
+        return false;
+    }
+
+    public function run(): true|string
+    {
+        return true;
+    }
+}
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_unknown_parameter.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_unknown_parameter.php.inc
new file mode 100644
index 00000000000..1247323ac5b
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_unknown_parameter.php.inc
@@ -0,0 +1,22 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+final class skip_unknown_parameter
+{
+    public function foo($a): string|int|float
+    {
+        return $a;
+    }
+
+    public function bar($a): string|int|null
+    {
+        if (rand(0, 1)) {
+            return 'something';
+        }
+
+        return $a;
+    }
+}
+
+?>
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/terminating_methods.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/terminating_methods.php.inc
new file mode 100644
index 00000000000..4a24bc1dacd
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/terminating_methods.php.inc
@@ -0,0 +1,123 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+final class TerminatingMethods
+{
+    public function alwaysReturns(): string|int|null
+    {
+        if (rand(0, 1)) {
+            return 'text';
+        } else {
+            return 42;
+        }
+    }
+
+    public function mixedTerminating(): string|int|null
+    {
+        if (rand(0, 1)) {
+            return 'text';
+        } elseif (rand(0, 1)) {
+            throw new \Exception('error');
+        } else {
+            exit(1);
+        }
+    }
+
+    public function switchTerminating(): string|int|null
+    {
+        switch (rand(0, 2)) {
+            case 0:
+                return 'zero';
+            case 1:
+                return 1;
+            default:
+                throw new \Exception('default');
+        }
+    }
+
+    public function tryFinallyTerminating(): string|int|null
+    {
+        try {
+            if (rand(0, 1)) {
+                return 'success';
+            }
+            throw new \Exception('error');
+        } finally {
+            return 'finally';
+        }
+    }
+
+    public function hasReturnButAlsoThrows(): string|int|null
+    {
+        if (rand(0, 1)) {
+            return 'text';
+        } else {
+            throw new \Exception('error');
+        }
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+final class TerminatingMethods
+{
+    public function alwaysReturns(): string|int
+    {
+        if (rand(0, 1)) {
+            return 'text';
+        } else {
+            return 42;
+        }
+    }
+
+    public function mixedTerminating(): string
+    {
+        if (rand(0, 1)) {
+            return 'text';
+        } elseif (rand(0, 1)) {
+            throw new \Exception('error');
+        } else {
+            exit(1);
+        }
+    }
+
+    public function switchTerminating(): string|int
+    {
+        switch (rand(0, 2)) {
+            case 0:
+                return 'zero';
+            case 1:
+                return 1;
+            default:
+                throw new \Exception('default');
+        }
+    }
+
+    public function tryFinallyTerminating(): string
+    {
+        try {
+            if (rand(0, 1)) {
+                return 'success';
+            }
+            throw new \Exception('error');
+        } finally {
+            return 'finally';
+        }
+    }
+
+    public function hasReturnButAlsoThrows(): string
+    {
+        if (rand(0, 1)) {
+            return 'text';
+        } else {
+            throw new \Exception('error');
+        }
+    }
+}
+
+?>
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/NarrowTooWideReturnTypeRectorTest.php b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/NarrowTooWideReturnTypeRectorTest.php
new file mode 100644
index 00000000000..02823bb43a2
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/NarrowTooWideReturnTypeRectorTest.php
@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector;
+
+use Iterator;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Rector\Testing\PHPUnit\AbstractRectorTestCase;
+
+final class NarrowTooWideReturnTypeRectorTest extends AbstractRectorTestCase
+{
+    #[DataProvider('provideData')]
+    public function test(string $filePath): void
+    {
+        $this->doTestFile($filePath);
+    }
+
+    public static function provideData(): Iterator
+    {
+        return self::yieldFilesFromDirectory(__DIR__ . '/Fixture');
+    }
+
+    public function provideConfigFilePath(): string
+    {
+        return __DIR__ . '/config/configured_rule.php';
+    }
+}
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Source/SomeAbstractClass.php b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Source/SomeAbstractClass.php
new file mode 100644
index 00000000000..82b85203a95
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Source/SomeAbstractClass.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Sourcet;
+
+abstract class SomeAbstractClass
+{
+    abstract public function process(): string|int|array;
+}
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Source/SomeInterface.php b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Source/SomeInterface.php
new file mode 100644
index 00000000000..70f80672847
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Source/SomeInterface.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Source;
+
+interface SomeInterface
+{
+    public function getData(): string|int|bool;
+}
diff --git a/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/config/configured_rule.php b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/config/configured_rule.php
new file mode 100644
index 00000000000..a96a0f92e6b
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/config/configured_rule.php
@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+use Rector\Config\RectorConfig;
+use Rector\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector;
+use Rector\ValueObject\PhpVersionFeature;
+
+return static function (RectorConfig $rectorConfig): void {
+    $rectorConfig->rule(NarrowTooWideReturnTypeRector::class);
+    $rectorConfig->phpVersion(PhpVersionFeature::UNION_TYPES);
+};
diff --git a/rules/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector.php b/rules/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector.php
new file mode 100644
index 00000000000..852a02859f3
--- /dev/null
+++ b/rules/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector.php
@@ -0,0 +1,308 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\DeadCode\Rector\FunctionLike;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr\ArrowFunction;
+use PhpParser\Node\Expr\Closure;
+use PhpParser\Node\Expr\ConstFetch;
+use PhpParser\Node\FunctionLike;
+use PhpParser\Node\Name;
+use PhpParser\Node\NullableType;
+use PhpParser\Node\Stmt\ClassMethod;
+use PhpParser\Node\Stmt\Function_;
+use PhpParser\Node\Stmt\Return_;
+use PhpParser\Node\UnionType;
+use PHPStan\PhpDocParser\Ast\PhpDoc\ReturnTagValueNode;
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\Type\NullType;
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
+use PHPStan\Type\UnionType as PHPStanUnionType;
+use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfo;
+use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory;
+use Rector\BetterPhpDocParser\PhpDocManipulator\PhpDocTypeChanger;
+use Rector\NodeTypeResolver\PHPStan\Type\TypeFactory;
+use Rector\PhpParser\Node\BetterNodeFinder;
+use Rector\PHPStanStaticTypeMapper\Enum\TypeKind;
+use Rector\Rector\AbstractRector;
+use Rector\Reflection\ReflectionResolver;
+use Rector\StaticTypeMapper\StaticTypeMapper;
+use Rector\TypeDeclaration\TypeInferer\SilentVoidResolver;
+use Rector\ValueObject\PhpVersionFeature;
+use Rector\VersionBonding\Contract\MinPhpVersionInterface;
+use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
+use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
+use Webmozart\Assert\Assert;
+
+/**
+ * @see \Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\NarrowTooWideReturnTypeRectorTest
+ */
+final class NarrowTooWideReturnTypeRector extends AbstractRector implements MinPhpVersionInterface
+{
+    public function __construct(
+        private readonly BetterNodeFinder $betterNodeFinder,
+        private readonly StaticTypeMapper $staticTypeMapper,
+        private readonly ReflectionResolver $reflectionResolver,
+        private readonly SilentVoidResolver $silentVoidResolver,
+        private readonly PhpDocTypeChanger $phpDocTypeChanger,
+        private readonly PhpDocInfoFactory $phpDocInfoFactory,
+        private readonly TypeFactory $typeFactory
+    ) {
+    }
+
+    public function getRuleDefinition(): RuleDefinition
+    {
+        return new RuleDefinition(
+            'Narrow too wide return type declarations if possible',
+            [
+                new CodeSample(
+                    <<<'CODE_SAMPLE'
+final class SomeClass
+{
+    public function foo(): string|int|\DateTime
+    {
+        if (rand(0, 1)) {
+            return 'text';
+        }
+
+        return 1000;
+    }
+}
+CODE_SAMPLE
+                    ,
+                    <<<'CODE_SAMPLE'
+final class SomeClass
+{
+    public function foo(): string|int
+    {
+        if (rand(0, 1)) {
+            return 'text';
+        }
+
+        return 1000;
+    }
+}
+CODE_SAMPLE
+                ),
+            ]
+        );
+    }
+
+    public function provideMinPhpVersion(): int
+    {
+        return PhpVersionFeature::NULLABLE_TYPE;
+    }
+
+    /**
+     * @return array<class-string<Node>>
+     */
+    public function getNodeTypes(): array
+    {
+        return [ClassMethod::class, Function_::class, Closure::class, ArrowFunction::class];
+    }
+
+    /**
+     * @param ClassMethod|Function_|Closure|ArrowFunction $node
+     */
+    public function refactor(Node $node): ?Node
+    {
+        if ($this->shouldSkipNode($node)) {
+            return null;
+        }
+
+        if ($this->shouldSkipByDocblock($node)) {
+            return null;
+        }
+
+        $returnStatements = $this->betterNodeFinder->findReturnsScoped($node);
+
+        if ($returnStatements === []) {
+            return null;
+        }
+
+        $hasImplicitNullReturn = $this->silentVoidResolver->hasSilentVoid($node)
+            || $this->hasImplicitNullReturn($returnStatements);
+
+        $returnType = $node->returnType;
+        Assert::isInstanceOfAny($returnType, [UnionType::class, NullableType::class]);
+
+        $returnType = $this->staticTypeMapper->mapPhpParserNodePHPStanType($returnType);
+        $actualReturnTypes = $this->collectActualReturnTypes($returnStatements);
+
+        if ($hasImplicitNullReturn) {
+            $actualReturnTypes[] = new NullType();
+        }
+
+        $unusedTypes = $this->getUnusedType($returnType, $actualReturnTypes);
+
+        if ($unusedTypes === []) {
+            return null;
+        }
+
+        $newReturnType = $this->staticTypeMapper->mapPHPStanTypeToPhpParserNode(
+            TypeCombinator::remove($returnType, TypeCombinator::union(...$unusedTypes)),
+            TypeKind::RETURN
+        );
+
+        if (! $newReturnType instanceof Node) {
+            return null;
+        }
+
+        // mostly placeholder
+        if ($this->isName($newReturnType, 'null')) {
+            return null;
+        }
+
+        $node->returnType = $newReturnType;
+
+        $phpDocInfo = $this->phpDocInfoFactory->createFromNode($node);
+
+        if ($phpDocInfo?->hasByName('@return') === true) {
+            $this->changePhpDocReturnType($node, $phpDocInfo, $unusedTypes);
+        }
+
+        return $node;
+    }
+
+    private function shouldSkipByDocblock(ClassMethod|Function_|Closure|ArrowFunction $node): bool
+    {
+        $phpDocInfo = $this->phpDocInfoFactory->createFromNode($node);
+
+        if (! $phpDocInfo instanceof PhpDocInfo) {
+            return false;
+        }
+
+        $returnTag = $phpDocInfo->getReturnTagValue();
+
+        if (! $returnTag instanceof ReturnTagValueNode) {
+            return false;
+        }
+
+        $returnType = $phpDocInfo->getReturnType();
+        if (! $returnType instanceof \PHPStan\Type\UnionType) {
+            return false;
+        }
+
+        $type = $this->typeFactory->createMixedPassedOrUnionType($returnType->getTypes());
+        return ! $type->equals($returnType);
+    }
+
+    private function shouldSkipNode(ClassMethod|Function_|Closure|ArrowFunction $node): bool
+    {
+        $returnType = $node->returnType;
+
+        if (! $returnType instanceof UnionType && ! $returnType instanceof NullableType) {
+            return true;
+        }
+
+        $types = $returnType instanceof UnionType
+            ? $returnType->types
+            : [new ConstFetch(new Name('null')), $returnType->type];
+
+        foreach ($types as $type) {
+            if ($this->isNames($type, ['true', 'false'])) {
+                return true;
+            }
+        }
+
+        if (! $node instanceof ClassMethod) {
+            return false;
+        }
+
+        if ($node->isPrivate() || $node->isFinal()) {
+            return false;
+        }
+
+        if ($node->isAbstract()) {
+            return true;
+        }
+
+        $classReflection = $this->reflectionResolver->resolveClassReflection($node);
+
+        if (! $classReflection instanceof ClassReflection) {
+            return true;
+        }
+
+        if (! $classReflection->isClass()) {
+            return true;
+        }
+
+        return ! $classReflection->isFinalByKeyword();
+    }
+
+    /**
+     * @param Return_[] $returnStatements
+     */
+    private function hasImplicitNullReturn(array $returnStatements): bool
+    {
+        foreach ($returnStatements as $returnStatement) {
+            if ($returnStatement->expr === null) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * @param Return_[] $returnStatements
+     * @return Type[]
+     */
+    private function collectActualReturnTypes(array $returnStatements): array
+    {
+        $returnTypes = [];
+
+        foreach ($returnStatements as $returnStatement) {
+            if ($returnStatement->expr === null) {
+                continue;
+            }
+
+            $returnTypes[] = $this->nodeTypeResolver->getNativeType($returnStatement->expr);
+        }
+
+        return $returnTypes;
+    }
+
+    /**
+     * @param Type[] $actualReturnTypes
+     * @return Type[]
+     */
+    private function getUnusedType(Type $returnType, array $actualReturnTypes): array
+    {
+        $types = $returnType instanceof PHPStanUnionType ? $returnType->getTypes() : [$returnType];
+        $unusedTypes = [];
+
+        foreach ($types as $type) {
+            foreach ($actualReturnTypes as $actualReturnType) {
+                if (! $type->isSuperTypeOf($actualReturnType)->no()) {
+                    continue 2;
+                }
+            }
+
+            $unusedTypes[] = $type;
+        }
+
+        return $unusedTypes;
+    }
+
+    /**
+     * @param Type[] $unusedTypes
+     */
+    private function changePhpDocReturnType(
+        FunctionLike $functionLike,
+        PhpDocInfo $phpDocInfo,
+        array $unusedTypes,
+    ): void {
+        $returnTagValueNode = $phpDocInfo->getReturnTagValue();
+
+        if (! $returnTagValueNode instanceof ReturnTagValueNode) {
+            return;
+        }
+
+        $newReturnType = TypeCombinator::remove($phpDocInfo->getReturnType(), TypeCombinator::union(...$unusedTypes));
+        $this->phpDocTypeChanger->changeReturnType($functionLike, $phpDocInfo, $newReturnType);
+    }
+}
diff --git a/rules/Php81/Rector/MethodCall/MyCLabsMethodCallToEnumConstRector.php b/rules/Php81/Rector/MethodCall/MyCLabsMethodCallToEnumConstRector.php
index 3d84aa194bb..40d7320af27 100644
--- a/rules/Php81/Rector/MethodCall/MyCLabsMethodCallToEnumConstRector.php
+++ b/rules/Php81/Rector/MethodCall/MyCLabsMethodCallToEnumConstRector.php
@@ -201,7 +201,7 @@ private function isCallerClassEnum(StaticCall|MethodCall $node): bool
         return $this->isObjectType($node->var, new ObjectType('MyCLabs\Enum\Enum'));
     }
 
-    private function getNonEnumReturnTypeExpr(Node $node): null|ClassConstFetch|Expr
+    private function getNonEnumReturnTypeExpr(Node $node): ?Expr
     {
         if (! $node instanceof StaticCall && ! $node instanceof MethodCall) {
             return null;
diff --git a/src/Config/Level/DeadCodeLevel.php b/src/Config/Level/DeadCodeLevel.php
index a67918d0597..b8dfcea0b28 100644
--- a/src/Config/Level/DeadCodeLevel.php
+++ b/src/Config/Level/DeadCodeLevel.php
@@ -35,6 +35,7 @@
 use Rector\DeadCode\Rector\For_\RemoveDeadLoopRector;
 use Rector\DeadCode\Rector\Foreach_\RemoveUnusedForeachKeyRector;
 use Rector\DeadCode\Rector\FuncCall\RemoveFilterVarOnExactTypeRector;
+use Rector\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector;
 use Rector\DeadCode\Rector\FunctionLike\RemoveDeadReturnRector;
 use Rector\DeadCode\Rector\If_\ReduceAlwaysFalseIfOrRector;
 use Rector\DeadCode\Rector\If_\RemoveAlwaysTrueIfConditionRector;
@@ -141,5 +142,6 @@ final class DeadCodeLevel
         RemoveDeadReturnRector::class,
 
         RemoveArgumentFromDefaultParentCallRector::class,
+        NarrowTooWideReturnTypeRector::class,
     ];
 }
diff --git a/src/PhpParser/Node/BetterNodeFinder.php b/src/PhpParser/Node/BetterNodeFinder.php
index 7979194ce70..86ec1521b04 100644
--- a/src/PhpParser/Node/BetterNodeFinder.php
+++ b/src/PhpParser/Node/BetterNodeFinder.php
@@ -5,15 +5,12 @@
 namespace Rector\PhpParser\Node;
 
 use PhpParser\Node;
-use PhpParser\Node\Expr\Closure;
 use PhpParser\Node\Expr\Variable;
 use PhpParser\Node\Expr\Yield_;
 use PhpParser\Node\Expr\YieldFrom;
 use PhpParser\Node\FunctionLike;
 use PhpParser\Node\Stmt;
 use PhpParser\Node\Stmt\Class_;
-use PhpParser\Node\Stmt\ClassMethod;
-use PhpParser\Node\Stmt\Function_;
 use PhpParser\Node\Stmt\Return_;
 use PhpParser\NodeFinder;
 use PhpParser\NodeVisitor;
@@ -158,17 +155,15 @@ public function findFirst(Node | array $nodes, callable $filter): ?Node
      * @template T of Node
      * @param array<class-string<T>>|class-string<T> $types
      */
-    public function hasInstancesOfInFunctionLikeScoped(
-        ClassMethod | Function_ | Closure $functionLike,
-        string|array $types
-    ): bool {
+    public function hasInstancesOfInFunctionLikeScoped(FunctionLike $functionLike, string|array $types): bool
+    {
         if (is_string($types)) {
             $types = [$types];
         }
 
         $isFoundNode = false;
         $this->simpleCallableNodeTraverser->traverseNodesWithCallable(
-            (array) $functionLike->stmts,
+            (array) $functionLike->getStmts(),
             static function (Node $subNode) use ($types, &$isFoundNode): ?int {
                 if ($subNode instanceof Class_ || $subNode instanceof FunctionLike) {
                     return NodeVisitor::DONT_TRAVERSE_CURRENT_AND_CHILDREN;
@@ -191,12 +186,12 @@ static function (Node $subNode) use ($types, &$isFoundNode): ?int {
     /**
      * @return Return_[]
      */
-    public function findReturnsScoped(ClassMethod | Function_ | Closure $functionLike): array
+    public function findReturnsScoped(FunctionLike $functionLike): array
     {
         $returns = [];
 
         $this->simpleCallableNodeTraverser->traverseNodesWithCallable(
-            (array) $functionLike->stmts,
+            (array) $functionLike->getStmts(),
             function (Node $subNode) use (&$returns): ?int {
                 if ($subNode instanceof Class_ || $subNode instanceof FunctionLike) {
                     return NodeVisitor::DONT_TRAVERSE_CURRENT_AND_CHILDREN;
@@ -267,24 +262,20 @@ static function (Node $subNode) use ($types, &$foundNodes): ?int {
      * @param array<class-string<T>>|class-string<T> $types
      * @return array<T>
      */
-    public function findInstancesOfInFunctionLikeScoped(
-        ClassMethod | Function_ | Closure $functionLike,
-        string|array $types
-    ): array {
+    public function findInstancesOfInFunctionLikeScoped(FunctionLike $functionLike, string|array $types): array
+    {
         return $this->findInstancesOfScoped([$functionLike], $types);
     }
 
     /**
      * @param callable(Node $node): bool $filter
      */
-    public function findFirstInFunctionLikeScoped(
-        ClassMethod | Function_ | Closure $functionLike,
-        callable $filter
-    ): ?Node {
+    public function findFirstInFunctionLikeScoped(FunctionLike $functionLike, callable $filter): ?Node
+    {
         $scopedNode = null;
 
         $this->simpleCallableNodeTraverser->traverseNodesWithCallable(
-            (array) $functionLike->stmts,
+            (array) $functionLike->getStmts(),
             function (Node $subNode) use (&$scopedNode, $filter): ?int {
                 if (! $filter($subNode)) {
                     if ($subNode instanceof Class_ || $subNode instanceof FunctionLike) {