diff --git a/phpstan.neon b/phpstan.neon
index 586f4e011f5..11cd05f8697 100644
--- a/phpstan.neon
+++ b/phpstan.neon
@@ -665,10 +665,6 @@ parameters:
             message: '#Offset 0 does not exist on array<PhpParser\\Node\\Stmt>\|null#'
             path:  rules/Php70/Rector/ClassMethod/Php4ConstructorRector.php
 
-        # resolve before Rector 1.0
-        - '#Call to deprecated method findParentType#'
-        - '#Call to deprecated method findParentByTypes#'
-
         - '#Cognitive complexity for "Rector\\Transform\\Rector\\StaticCall\\StaticCallToMethodCallRector\:\:refactorWithScope\(\)" is 14, keep it under 11#'
         - '#Cognitive complexity for "Rector\\TypeDeclaration\\Rector\\ClassMethod\\ParamTypeByMethodCallTypeRector\:\:refactorWithScope\(\)" is 13, keep it under 11#'
 
diff --git a/rules/Php72/NodeFactory/AnonymousFunctionFactory.php b/rules/Php72/NodeFactory/AnonymousFunctionFactory.php
index 5744fea1067..b8fd8054aa3 100644
--- a/rules/Php72/NodeFactory/AnonymousFunctionFactory.php
+++ b/rules/Php72/NodeFactory/AnonymousFunctionFactory.php
@@ -44,7 +44,6 @@
 use Rector\Core\Util\Reflection\PrivatesAccessor;
 use Rector\NodeNameResolver\NodeNameResolver;
 use Rector\NodeTypeResolver\Node\AttributeKey;
-use Rector\Php72\NodeManipulator\ClosureNestedUsesDecorator;
 use Rector\PhpDocParser\NodeTraverser\SimpleCallableNodeTraverser;
 use Rector\PHPStanStaticTypeMapper\Enum\TypeKind;
 use Rector\StaticTypeMapper\StaticTypeMapper;
@@ -65,7 +64,6 @@ public function __construct(
         private readonly StaticTypeMapper $staticTypeMapper,
         private readonly SimpleCallableNodeTraverser $simpleCallableNodeTraverser,
         private readonly SimplePhpParser $simplePhpParser,
-        private readonly ClosureNestedUsesDecorator $closureNestedUsesDecorator,
         private readonly AstResolver $astResolver,
         private readonly PrivatesAccessor $privatesAccessor,
         private readonly InlineCodeParser $inlineCodeParser
@@ -85,27 +83,23 @@ public function create(
     ): Closure {
         $useVariables = $this->createUseVariablesFromParams($stmts, $params);
 
-        $anonymousFunctionNode = new Closure();
-        $anonymousFunctionNode->params = $params;
+        $anonymousFunctionClosure = new Closure();
+        $anonymousFunctionClosure->params = $params;
 
         if ($static) {
-            $anonymousFunctionNode->static = $static;
+            $anonymousFunctionClosure->static = $static;
         }
 
         foreach ($useVariables as $useVariable) {
-            $anonymousFunctionNode = $this->closureNestedUsesDecorator->applyNestedUses(
-                $anonymousFunctionNode,
-                $useVariable
-            );
-            $anonymousFunctionNode->uses[] = new ClosureUse($useVariable);
+            $anonymousFunctionClosure->uses[] = new ClosureUse($useVariable);
         }
 
         if ($returnTypeNode instanceof Node) {
-            $anonymousFunctionNode->returnType = $returnTypeNode;
+            $anonymousFunctionClosure->returnType = $returnTypeNode;
         }
 
-        $anonymousFunctionNode->stmts = $stmts;
-        return $anonymousFunctionNode;
+        $anonymousFunctionClosure->stmts = $stmts;
+        return $anonymousFunctionClosure;
     }
 
     public function createFromPhpMethodReflection(PhpMethodReflection $phpMethodReflection, Expr $expr): ?Closure
diff --git a/rules/Php72/NodeManipulator/ClosureNestedUsesDecorator.php b/rules/Php72/NodeManipulator/ClosureNestedUsesDecorator.php
deleted file mode 100644
index 73f6f259d89..00000000000
--- a/rules/Php72/NodeManipulator/ClosureNestedUsesDecorator.php
+++ /dev/null
@@ -1,96 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Rector\Php72\NodeManipulator;
-
-use PhpParser\Node\Expr\Closure;
-use PhpParser\Node\Expr\ClosureUse;
-use PhpParser\Node\Expr\Variable;
-use Rector\Core\PhpParser\Comparing\NodeComparator;
-use Rector\Core\PhpParser\Node\BetterNodeFinder;
-use Rector\NodeNameResolver\NodeNameResolver;
-
-final class ClosureNestedUsesDecorator
-{
-    public function __construct(
-        private readonly BetterNodeFinder $betterNodeFinder,
-        private readonly NodeNameResolver $nodeNameResolver,
-        private readonly NodeComparator $nodeComparator,
-    ) {
-    }
-
-    public function applyNestedUses(Closure $anonymousFunctionNode, Variable $useVariable): Closure
-    {
-        $parentNode = $this->betterNodeFinder->findParentType($useVariable, Closure::class);
-        if (! $parentNode instanceof Closure) {
-            return $anonymousFunctionNode;
-        }
-
-        $paramNames = $this->nodeNameResolver->getNames($parentNode->params);
-
-        if ($this->nodeNameResolver->isNames($useVariable, $paramNames)) {
-            return $anonymousFunctionNode;
-        }
-
-        $anonymousFunctionNode = clone $anonymousFunctionNode;
-        while ($parentNode instanceof Closure) {
-            $parentOfParent = $this->betterNodeFinder->findParentType($parentNode, Closure::class);
-
-            $uses = [];
-            while ($parentOfParent instanceof Closure) {
-                $uses = $this->collectUsesEqual($parentOfParent, $uses, $useVariable);
-                $parentOfParent = $this->betterNodeFinder->findParentType($parentOfParent, Closure::class);
-            }
-
-            $uses = array_merge($parentNode->uses, $uses);
-            $parentNode->uses = $this->cleanClosureUses($uses);
-
-            $parentNode = $this->betterNodeFinder->findParentType($parentNode, Closure::class);
-        }
-
-        return $anonymousFunctionNode;
-    }
-
-    /**
-     * @param ClosureUse[] $uses
-     * @return ClosureUse[]
-     */
-    private function collectUsesEqual(Closure $closure, array $uses, Variable $useVariable): array
-    {
-        foreach ($closure->params as $param) {
-            if (! $param->var instanceof Variable) {
-                continue;
-            }
-
-            if ($this->nodeComparator->areNodesEqual($param->var, $useVariable)) {
-                $uses[] = new ClosureUse($param->var);
-            }
-        }
-
-        return $uses;
-    }
-
-    /**
-     * @param ClosureUse[] $uses
-     * @return ClosureUse[]
-     */
-    private function cleanClosureUses(array $uses): array
-    {
-        $uniqueUses = [];
-        foreach ($uses as $use) {
-            if (! is_string($use->var->name)) {
-                continue;
-            }
-
-            $variableName = $use->var->name;
-            if (array_key_exists($variableName, $uniqueUses)) {
-                continue;
-            }
-
-            $uniqueUses[$variableName] = $use;
-        }
-
-        return array_values($uniqueUses);
-    }
-}
diff --git a/src/PhpParser/Node/BetterNodeFinder.php b/src/PhpParser/Node/BetterNodeFinder.php
index 917afb4663c..a945711af65 100644
--- a/src/PhpParser/Node/BetterNodeFinder.php
+++ b/src/PhpParser/Node/BetterNodeFinder.php
@@ -57,29 +57,6 @@ public function __construct(
     ) {
     }
 
-    /**
-     * @deprecated Make use of child nodes instead
-     * @param class-string<T> $type
-     * @template T of Node
-     * @return T|null
-     */
-    public function findParentType(Node $node, string $type): ?Node
-    {
-        Assert::isAOf($type, Node::class);
-
-        $parentNode = $node->getAttribute(AttributeKey::PARENT_NODE);
-
-        while ($parentNode instanceof Node) {
-            if ($parentNode instanceof $type) {
-                return $parentNode;
-            }
-
-            $parentNode = $parentNode->getAttribute(AttributeKey::PARENT_NODE);
-        }
-
-        return null;
-    }
-
     /**
      * @template T of Node
      * @param array<class-string<T>> $types
diff --git a/tests/PhpParser/Node/BetterNodeFinder/BetterNodeFinderTest.php b/tests/PhpParser/Node/BetterNodeFinder/BetterNodeFinderTest.php
index 7b1075e33c0..b88f30365e6 100644
--- a/tests/PhpParser/Node/BetterNodeFinder/BetterNodeFinderTest.php
+++ b/tests/PhpParser/Node/BetterNodeFinder/BetterNodeFinderTest.php
@@ -5,10 +5,8 @@
 namespace Rector\Core\Tests\PhpParser\Node\BetterNodeFinder;
 
 use PhpParser\Node;
-use PhpParser\Node\Expr\Array_;
 use PhpParser\Node\Expr\Variable;
 use PhpParser\Node\Stmt\Class_;
-use PhpParser\Node\Stmt\ClassLike;
 use Rector\Core\PhpParser\Node\BetterNodeFinder;
 use Rector\Core\PhpParser\Parser\SimplePhpParser;
 use Rector\Testing\PHPUnit\AbstractLazyTestCase;
@@ -37,17 +35,5 @@ public function testFindFirstAncestorInstanceOf(): void
 
         $this->assertInstanceOf(Variable::class, $variable);
         $this->assertInstanceOf(Class_::class, $class);
-
-        /** @var Variable $variable */
-        $classLikeNode = $this->betterNodeFinder->findParentType($variable, ClassLike::class);
-        $this->assertSame($classLikeNode, $class);
-    }
-
-    public function testFindMissingFirstAncestorInstanceOf(): void
-    {
-        /** @var Variable $variableNode */
-        $variableNode = $this->betterNodeFinder->findFirstInstanceOf($this->nodes, Variable::class);
-
-        $this->assertNull($this->betterNodeFinder->findParentType($variableNode, Array_::class));
     }
 }