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..d81eef00908
--- /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(int $x): string|int|bool => $x > 5 ? 'high' : 10;
+
+$ternary = fn(?int $value): string|int|float|null =>
+    $value === null ? null : ($value > 0 ? 'positive' : -1);
+
+$cast = fn(mixed $input): int|string|array => (int) $input;
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\FunctionLike\NarrowTooWideReturnTypeRector\Fixture;
+
+$simple = fn(int $x): string|int => $x > 5 ? 'high' : 10;
+
+$ternary = fn(?int $value): string|int|null =>
+    $value === null ? null : ($value > 0 ? 'positive' : -1);
+
+$cast = fn(mixed $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..0afdfd50865
--- /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(): string|int
+    {
+        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_function_likes_without_parameter_types.php.inc b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_function_likes_without_parameter_types.php.inc
new file mode 100644
index 00000000000..b29f390e5f4
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_function_likes_without_parameter_types.php.inc
@@ -0,0 +1,17 @@
+<?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;
+    }
+}
+
+?>
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..0371e26d348
--- /dev/null
+++ b/rules-tests/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector/Fixture/skip_generator.php.inc
@@ -0,0 +1,23 @@
+<?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 null;
+    }
+
+    public function delegate(): \Generator|array
+    {
+        yield from [1, 2, 3];
+    }
+}
+
+?>
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_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_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..526674e472f
--- /dev/null
+++ b/rules/DeadCode/Rector/FunctionLike/NarrowTooWideReturnTypeRector.php
@@ -0,0 +1,265 @@
+<?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\Yield_;
+use PhpParser\Node\Expr\YieldFrom;
+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\Analyser\Scope;
+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\PhpParser\Node\BetterNodeFinder;
+use Rector\PHPStan\ScopeFetcher;
+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,
+    ) {
+    }
+
+    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
+    {
+        $scope = ScopeFetcher::fetch($node);
+
+        if ($this->shouldSkipNode($node, $scope)) {
+            return null;
+        }
+
+        $returnStatements = $node instanceof ArrowFunction
+            ? []
+            : $this->betterNodeFinder->findReturnsScoped($node);
+        $isAlwaysTerminating = ! $this->silentVoidResolver->hasSilentVoid($node);
+
+        if ($returnStatements === [] && ! $node instanceof ArrowFunction) {
+            return null;
+        }
+
+        $phpDocInfo = $this->phpDocInfoFactory->createFromNode($node);
+        $hasReturnDocblock = (bool) $phpDocInfo?->hasByName('@return');
+
+        if ($hasReturnDocblock) {
+            $returnType = $phpDocInfo->getReturnType();
+        } else {
+            $returnType = $node->returnType;
+            Assert::isInstanceOfAny($returnType, [UnionType::class, NullableType::class]);
+            $returnType = $this->staticTypeMapper->mapPhpParserNodePHPStanType($returnType);
+        }
+
+        $actualReturnTypes = $this->collectActualReturnTypes($node, $returnStatements, $isAlwaysTerminating);
+        $newReturnType = $this->narrowReturnType($returnType, $actualReturnTypes);
+
+        if ($newReturnType === null) {
+            return null;
+        }
+
+        $node->returnType = $this->staticTypeMapper->mapPHPStanTypeToPhpParserNode(
+            $newReturnType,
+            TypeKind::RETURN
+        );
+
+        if ($hasReturnDocblock) {
+            $this->phpDocTypeChanger->changeReturnType($node, $phpDocInfo, $newReturnType);
+        }
+
+        return $node;
+    }
+
+    private function shouldSkipNode(ClassMethod|Function_|Closure|ArrowFunction $node, Scope $scope): bool
+    {
+        $returnType = $node->returnType;
+
+        if (! $returnType instanceof UnionType && ! $returnType instanceof NullableType) {
+            return true;
+        }
+
+        if ($this->hasYield($node)) {
+            return true;
+        }
+
+        foreach ($node->params as $param) {
+            if (! $param->type instanceof Node) {
+                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
+     * @return Type[]
+     */
+    private function collectActualReturnTypes(
+        ClassMethod|Function_|Closure|ArrowFunction $node,
+        array $returnStatements,
+        bool $isAlwaysTerminating,
+    ): array {
+        if ($node instanceof ArrowFunction) {
+            return [$this->getType($node->expr)];
+        }
+
+        $returnTypes = [];
+        foreach ($returnStatements as $returnStatement) {
+            if ($returnStatement->expr === null) {
+                $returnTypes[] = new NullType();
+                continue;
+            }
+
+            $returnTypes[] = $this->getType($returnStatement->expr);
+        }
+
+        if (! $isAlwaysTerminating) {
+            $returnTypes[] = new NullType();
+        }
+
+        return $returnTypes;
+    }
+
+    /**
+     * @param Type[] $actualReturnTypes
+     */
+    private function narrowReturnType(Type $returnType, array $actualReturnTypes): Type|null
+    {
+        $types = $returnType instanceof PHPStanUnionType ? $returnType->getTypes() : [$returnType];
+        $usedTypes = [];
+
+        foreach ($types as $type) {
+            foreach ($actualReturnTypes as $actualType) {
+                if (! $type->isSuperTypeOf($actualType)->no()) {
+                    $usedTypes[] = $type;
+                    break;
+                }
+            }
+        }
+
+        $usedTypes = array_unique($usedTypes, SORT_REGULAR);
+
+        if ($usedTypes === [] || count($usedTypes) === count($types)) {
+            return null;
+        }
+
+        return TypeCombinator::union(...$usedTypes);
+    }
+
+    private function hasYield(ClassMethod|Function_|Closure|ArrowFunction $node): bool
+    {
+        if ($node instanceof ArrowFunction) {
+            return false;
+        }
+
+        return (bool) $this->betterNodeFinder->hasInstancesOfInFunctionLikeScoped(
+            $node,
+            [Yield_::class, YieldFrom::class]
+        );
+    }
+}
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,
     ];
 }