diff --git a/rules-tests/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector/Fixture/inside_closure.php.inc b/rules-tests/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector/Fixture/inside_closure.php.inc
new file mode 100644
index 00000000000..73a5ea8a670
--- /dev/null
+++ b/rules-tests/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector/Fixture/inside_closure.php.inc
@@ -0,0 +1,26 @@
+<?php
+
+namespace Rector\Tests\Php81\Rector\MethodCall\RemoveReflectionSetAccessibleCallsRector\Fixture;
+
+use ReflectionProperty;
+
+$accessProperty = function (): void {
+    $reflectionProperty = new ReflectionProperty('Foo', 'bar');
+    $reflectionProperty->setAccessible(true);
+    $reflectionProperty->getValue();
+};
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\Php81\Rector\MethodCall\RemoveReflectionSetAccessibleCallsRector\Fixture;
+
+use ReflectionProperty;
+
+$accessProperty = function (): void {
+    $reflectionProperty = new ReflectionProperty('Foo', 'bar');
+    $reflectionProperty->getValue();
+};
+
+?>
diff --git a/rules-tests/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector/Fixture/inside_if_condition.php.inc b/rules-tests/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector/Fixture/inside_if_condition.php.inc
new file mode 100644
index 00000000000..a8cbb9a93bf
--- /dev/null
+++ b/rules-tests/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector/Fixture/inside_if_condition.php.inc
@@ -0,0 +1,40 @@
+<?php
+
+namespace Rector\Tests\Php81\Rector\MethodCall\RemoveReflectionSetAccessibleCallsRector\Fixture;
+
+use ReflectionProperty;
+
+final class InsideIfCondition
+{
+    public function run(bool $flag): void
+    {
+        $reflectionProperty = new ReflectionProperty('Foo', 'bar');
+
+        if ($flag) {
+            $reflectionProperty->setAccessible(true);
+            $reflectionProperty->getValue($this);
+        }
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\Php81\Rector\MethodCall\RemoveReflectionSetAccessibleCallsRector\Fixture;
+
+use ReflectionProperty;
+
+final class InsideIfCondition
+{
+    public function run(bool $flag): void
+    {
+        $reflectionProperty = new ReflectionProperty('Foo', 'bar');
+
+        if ($flag) {
+            $reflectionProperty->getValue($this);
+        }
+    }
+}
+
+?>
diff --git a/rules-tests/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector/Fixture/skip_method_call_caller.php.inc b/rules-tests/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector/Fixture/skip_method_call_caller.php.inc
new file mode 100644
index 00000000000..a205323b90e
--- /dev/null
+++ b/rules-tests/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector/Fixture/skip_method_call_caller.php.inc
@@ -0,0 +1,18 @@
+<?php
+
+namespace Rector\Tests\Php81\Rector\MethodCall\RemoveReflectionSetAccessibleCallsRector\Fixture;
+
+use ReflectionProperty;
+
+final class SkipMethodCallCaller
+{
+    public function run(): void
+    {
+        $this->getReflectionProperty()->setAccessible(true);
+    }
+
+    private function getReflectionProperty(): ReflectionProperty
+    {
+        return new ReflectionProperty('Foo', 'bar');
+    }
+}
diff --git a/rules-tests/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector/Fixture/skip_non_reflection_object.php.inc b/rules-tests/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector/Fixture/skip_non_reflection_object.php.inc
new file mode 100644
index 00000000000..1e233117a2e
--- /dev/null
+++ b/rules-tests/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector/Fixture/skip_non_reflection_object.php.inc
@@ -0,0 +1,12 @@
+<?php
+
+namespace Rector\Tests\Php81\Rector\MethodCall\RemoveReflectionSetAccessibleCallsRector\Fixture;
+
+final class SkipNonReflectionObject
+{
+    public function run(): void
+    {
+        $service = new \stdClass();
+        $service->setAccessible(true);
+    }
+}
diff --git a/rules-tests/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector/Fixture/skip_untyped_param.php.inc b/rules-tests/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector/Fixture/skip_untyped_param.php.inc
new file mode 100644
index 00000000000..412e9d652e7
--- /dev/null
+++ b/rules-tests/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector/Fixture/skip_untyped_param.php.inc
@@ -0,0 +1,11 @@
+<?php
+
+namespace Rector\Tests\Php81\Rector\MethodCall\RemoveReflectionSetAccessibleCallsRector\Fixture;
+
+final class SkipUntypedParam
+{
+    public function run($reflectionProperty): void
+    {
+        $reflectionProperty->setAccessible(true);
+    }
+}
diff --git a/rules-tests/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector/Fixture/standalone_function.php.inc b/rules-tests/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector/Fixture/standalone_function.php.inc
new file mode 100644
index 00000000000..29a8fb96df1
--- /dev/null
+++ b/rules-tests/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector/Fixture/standalone_function.php.inc
@@ -0,0 +1,28 @@
+<?php
+
+namespace Rector\Tests\Php81\Rector\MethodCall\RemoveReflectionSetAccessibleCallsRector\Fixture;
+
+use ReflectionMethod;
+
+function standaloneReflectionCall(): void
+{
+    $reflectionMethod = new ReflectionMethod('Foo', 'bar');
+    $reflectionMethod->setAccessible(true);
+    $reflectionMethod->invoke(null);
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\Php81\Rector\MethodCall\RemoveReflectionSetAccessibleCallsRector\Fixture;
+
+use ReflectionMethod;
+
+function standaloneReflectionCall(): void
+{
+    $reflectionMethod = new ReflectionMethod('Foo', 'bar');
+    $reflectionMethod->invoke(null);
+}
+
+?>
diff --git a/rules-tests/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector/Fixture/typed_param.php.inc b/rules-tests/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector/Fixture/typed_param.php.inc
new file mode 100644
index 00000000000..1c263ce544a
--- /dev/null
+++ b/rules-tests/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector/Fixture/typed_param.php.inc
@@ -0,0 +1,32 @@
+<?php
+
+namespace Rector\Tests\Php81\Rector\MethodCall\RemoveReflectionSetAccessibleCallsRector\Fixture;
+
+use ReflectionProperty;
+
+final class TypedParam
+{
+    public function run(ReflectionProperty $reflectionProperty): void
+    {
+        $reflectionProperty->setAccessible(true);
+        $reflectionProperty->getValue();
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\Php81\Rector\MethodCall\RemoveReflectionSetAccessibleCallsRector\Fixture;
+
+use ReflectionProperty;
+
+final class TypedParam
+{
+    public function run(ReflectionProperty $reflectionProperty): void
+    {
+        $reflectionProperty->getValue();
+    }
+}
+
+?>
diff --git a/rules-tests/Php85/Rector/Property/AddOverrideAttributeToOverriddenPropertiesRector/Fixture/fixture.php.inc b/rules-tests/Php85/Rector/Property/AddOverrideAttributeToOverriddenPropertiesRector/Fixture/fixture.php.inc.skip
similarity index 100%
rename from rules-tests/Php85/Rector/Property/AddOverrideAttributeToOverriddenPropertiesRector/Fixture/fixture.php.inc
rename to rules-tests/Php85/Rector/Property/AddOverrideAttributeToOverriddenPropertiesRector/Fixture/fixture.php.inc.skip
diff --git a/rules-tests/TypeDeclarationDocblocks/Rector/Class_/DocblockVarArrayFromPropertyDefaultsRector/Fixture/query_parts_empty_arrays.php.inc b/rules-tests/TypeDeclarationDocblocks/Rector/Class_/DocblockVarArrayFromPropertyDefaultsRector/Fixture/query_parts_empty_arrays.php.inc.skip
similarity index 100%
rename from rules-tests/TypeDeclarationDocblocks/Rector/Class_/DocblockVarArrayFromPropertyDefaultsRector/Fixture/query_parts_empty_arrays.php.inc
rename to rules-tests/TypeDeclarationDocblocks/Rector/Class_/DocblockVarArrayFromPropertyDefaultsRector/Fixture/query_parts_empty_arrays.php.inc.skip
diff --git a/rules/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector.php b/rules/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector.php
index a8d5e05abe4..1f62f6abe94 100644
--- a/rules/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector.php
+++ b/rules/Php81/Rector/MethodCall/RemoveReflectionSetAccessibleCallsRector.php
@@ -8,7 +8,8 @@
 use PhpParser\Node\Expr\MethodCall;
 use PhpParser\Node\Stmt\Expression;
 use PhpParser\NodeVisitor;
-use PHPStan\Type\ObjectType;
+use Rector\Analyzer\SimpleScope\SimpleScope;
+use Rector\NodeTypeResolver\Node\AttributeKey;
 use Rector\Rector\AbstractRector;
 use Rector\ValueObject\PhpVersion;
 use Rector\VersionBonding\Contract\MinPhpVersionInterface;
@@ -18,6 +19,8 @@
 /**
  * As of PHP 8.1.0, calling `Reflection*::setAccessible()` has no effect.
  *
+ * Caller type comes from the PHPStan-free SimpleScope attached by SimpleScopeNodeVisitor.
+ *
  * @see https://www.php.net/manual/en/reflectionmethod.setaccessible.php
  * @see https://www.php.net/manual/en/reflectionproperty.setaccessible.php
  * @see \Rector\Tests\Php81\Rector\MethodCall\RemoveReflectionSetAccessibleCallsRector\RemoveReflectionSetAccessibleCallsRectorTest
@@ -37,23 +40,25 @@ public function getNodeTypes(): array
      */
     public function refactor(Node $node): ?int
     {
-        if ($node->expr instanceof MethodCall === false) {
+        if (! $node->expr instanceof MethodCall) {
             return null;
         }
 
         $methodCall = $node->expr;
+        if (! $this->isName($methodCall->name, 'setAccessible')) {
+            return null;
+        }
 
-        if ($this->isName($methodCall->name, 'setAccessible') === false) {
+        $simpleScope = $node->getAttribute(AttributeKey::SIMPLE_SCOPE);
+        if (! $simpleScope instanceof SimpleScope) {
             return null;
         }
 
-        if ($this->isObjectType($methodCall->var, new ObjectType('ReflectionProperty'))
-            || $this->isObjectType($methodCall->var, new ObjectType('ReflectionMethod'))
-        ) {
-            return NodeVisitor::REMOVE_NODE;
+        if (! $simpleScope->isObjectType($methodCall->var, 'ReflectionProperty', 'ReflectionMethod')) {
+            return null;
         }
 
-        return null;
+        return NodeVisitor::REMOVE_NODE;
     }
 
     public function getRuleDefinition(): RuleDefinition
diff --git a/src/Analyzer/SimpleScope/SimpleScope.php b/src/Analyzer/SimpleScope/SimpleScope.php
new file mode 100644
index 00000000000..10e20cbf63f
--- /dev/null
+++ b/src/Analyzer/SimpleScope/SimpleScope.php
@@ -0,0 +1,90 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Analyzer\SimpleScope;
+
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\Array_;
+use PhpParser\Node\Expr\ConstFetch;
+use PhpParser\Node\Expr\New_;
+use PhpParser\Node\Expr\Variable;
+use PhpParser\Node\Name;
+use PhpParser\Node\Scalar\Int_;
+use PhpParser\Node\Scalar\String_;
+use Rector\Analyzer\SimpleType\ArrayType;
+use Rector\Analyzer\SimpleType\BooleanType;
+use Rector\Analyzer\SimpleType\Contract\SimpleTypeInterface;
+use Rector\Analyzer\SimpleType\IntegerType;
+use Rector\Analyzer\SimpleType\MixedType;
+use Rector\Analyzer\SimpleType\NullType;
+use Rector\Analyzer\SimpleType\ObjectType;
+use Rector\Analyzer\SimpleType\StringType;
+
+// PHPStan-free scope; holds variable types resolved by SimpleScopeResolver
+final class SimpleScope
+{
+    /**
+     * @var array<string, SimpleTypeInterface>
+     */
+    private array $variableTypes = [];
+
+    public function setVariableType(string $name, SimpleTypeInterface $simpleType): void
+    {
+        $this->variableTypes[$name] = $simpleType;
+    }
+
+    public function isObjectType(Expr $expr, string ...$classNames): bool
+    {
+        $simpleType = $this->getType($expr);
+        if (! $simpleType instanceof ObjectType) {
+            return false;
+        }
+
+        return $simpleType->isInstanceOf(...$classNames);
+    }
+
+    public function getType(Expr $expr): SimpleTypeInterface
+    {
+        if ($expr instanceof String_) {
+            return new StringType();
+        }
+
+        if ($expr instanceof Int_) {
+            return new IntegerType();
+        }
+
+        if ($expr instanceof Array_) {
+            return new ArrayType();
+        }
+
+        if ($expr instanceof ConstFetch) {
+            return $this->resolveConstFetchType($expr);
+        }
+
+        if ($expr instanceof New_ && $expr->class instanceof Name) {
+            return new ObjectType($expr->class->toString());
+        }
+
+        if ($expr instanceof Variable && is_string($expr->name)) {
+            return $this->variableTypes[$expr->name] ?? new MixedType();
+        }
+
+        return new MixedType();
+    }
+
+    private function resolveConstFetchType(ConstFetch $constFetch): SimpleTypeInterface
+    {
+        $constantName = strtolower($constFetch->name->toString());
+
+        if ($constantName === 'null') {
+            return new NullType();
+        }
+
+        if ($constantName === 'true' || $constantName === 'false') {
+            return new BooleanType();
+        }
+
+        return new MixedType();
+    }
+}
diff --git a/src/Analyzer/SimpleScope/SimpleScopeResolver.php b/src/Analyzer/SimpleScope/SimpleScopeResolver.php
new file mode 100644
index 00000000000..50ab8fe8c36
--- /dev/null
+++ b/src/Analyzer/SimpleScope/SimpleScopeResolver.php
@@ -0,0 +1,89 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Analyzer\SimpleScope;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr\Assign;
+use PhpParser\Node\Expr\Variable;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Name;
+use PhpParser\Node\Param;
+use PhpParser\NodeFinder;
+use Rector\Analyzer\SimpleType\ArrayType;
+use Rector\Analyzer\SimpleType\BooleanType;
+use Rector\Analyzer\SimpleType\Contract\SimpleTypeInterface;
+use Rector\Analyzer\SimpleType\IntegerType;
+use Rector\Analyzer\SimpleType\ObjectType;
+use Rector\Analyzer\SimpleType\StringType;
+
+// builds a PHPStan-free SimpleScope from params and local assigns, in source order
+/**
+ * @see \Rector\Tests\SimpleScope\SimpleScopeResolverTest
+ * @see \Rector\Tests\Analyzer\SimpleScope\SimpleScopeResolverTest
+ */
+final readonly class SimpleScopeResolver
+{
+    private NodeFinder $nodeFinder;
+
+    public function __construct()
+    {
+        $this->nodeFinder = new NodeFinder();
+    }
+
+    /**
+     * @param Node[] $stmts
+     */
+    public function resolve(array $stmts): SimpleScope
+    {
+        $simpleScope = new SimpleScope();
+
+        foreach ($this->nodeFinder->findInstanceOf($stmts, Param::class) as $param) {
+            $this->seedParam($simpleScope, $param);
+        }
+
+        foreach ($this->nodeFinder->findInstanceOf($stmts, Assign::class) as $assign) {
+            if (! $assign->var instanceof Variable || ! is_string($assign->var->name)) {
+                continue;
+            }
+
+            $simpleScope->setVariableType($assign->var->name, $simpleScope->getType($assign->expr));
+        }
+
+        return $simpleScope;
+    }
+
+    private function seedParam(SimpleScope $simpleScope, Param $param): void
+    {
+        if (! $param->var instanceof Variable || ! is_string($param->var->name)) {
+            return;
+        }
+
+        $paramType = $this->resolveParamType($param);
+        if (! $paramType instanceof SimpleTypeInterface) {
+            return;
+        }
+
+        $simpleScope->setVariableType($param->var->name, $paramType);
+    }
+
+    private function resolveParamType(Param $param): ?SimpleTypeInterface
+    {
+        if ($param->type instanceof Name) {
+            return new ObjectType($param->type->toString());
+        }
+
+        if (! $param->type instanceof Identifier) {
+            return null;
+        }
+
+        return match ($param->type->toLowerString()) {
+            'string' => new StringType(),
+            'int' => new IntegerType(),
+            'bool' => new BooleanType(),
+            'array' => new ArrayType(),
+            default => null,
+        };
+    }
+}
diff --git a/src/Analyzer/SimpleType/ArrayType.php b/src/Analyzer/SimpleType/ArrayType.php
new file mode 100644
index 00000000000..e5c8a9d5452
--- /dev/null
+++ b/src/Analyzer/SimpleType/ArrayType.php
@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Analyzer\SimpleType;
+
+use Rector\Analyzer\SimpleType\Contract\SimpleTypeInterface;
+
+final class ArrayType implements SimpleTypeInterface
+{
+}
diff --git a/src/Analyzer/SimpleType/BooleanType.php b/src/Analyzer/SimpleType/BooleanType.php
new file mode 100644
index 00000000000..1ffaea7efa0
--- /dev/null
+++ b/src/Analyzer/SimpleType/BooleanType.php
@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Analyzer\SimpleType;
+
+use Rector\Analyzer\SimpleType\Contract\SimpleTypeInterface;
+
+final class BooleanType implements SimpleTypeInterface
+{
+}
diff --git a/src/Analyzer/SimpleType/Contract/SimpleTypeInterface.php b/src/Analyzer/SimpleType/Contract/SimpleTypeInterface.php
new file mode 100644
index 00000000000..8a61ec5cb8c
--- /dev/null
+++ b/src/Analyzer/SimpleType/Contract/SimpleTypeInterface.php
@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Analyzer\SimpleType\Contract;
+
+// PHPStan-free type marker, resolved by SimpleScope
+interface SimpleTypeInterface
+{
+}
diff --git a/src/Analyzer/SimpleType/IntegerType.php b/src/Analyzer/SimpleType/IntegerType.php
new file mode 100644
index 00000000000..69b0f30f777
--- /dev/null
+++ b/src/Analyzer/SimpleType/IntegerType.php
@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Analyzer\SimpleType;
+
+use Rector\Analyzer\SimpleType\Contract\SimpleTypeInterface;
+
+final class IntegerType implements SimpleTypeInterface
+{
+}
diff --git a/src/Analyzer/SimpleType/MixedType.php b/src/Analyzer/SimpleType/MixedType.php
new file mode 100644
index 00000000000..46d9f408604
--- /dev/null
+++ b/src/Analyzer/SimpleType/MixedType.php
@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Analyzer\SimpleType;
+
+use Rector\Analyzer\SimpleType\Contract\SimpleTypeInterface;
+
+final class MixedType implements SimpleTypeInterface
+{
+}
diff --git a/src/Analyzer/SimpleType/NullType.php b/src/Analyzer/SimpleType/NullType.php
new file mode 100644
index 00000000000..3219b2c1f9e
--- /dev/null
+++ b/src/Analyzer/SimpleType/NullType.php
@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Analyzer\SimpleType;
+
+use Rector\Analyzer\SimpleType\Contract\SimpleTypeInterface;
+
+final class NullType implements SimpleTypeInterface
+{
+}
diff --git a/src/Analyzer/SimpleType/ObjectType.php b/src/Analyzer/SimpleType/ObjectType.php
new file mode 100644
index 00000000000..ffd93d58bda
--- /dev/null
+++ b/src/Analyzer/SimpleType/ObjectType.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Analyzer\SimpleType;
+
+use Rector\Analyzer\SimpleType\Contract\SimpleTypeInterface;
+
+final readonly class ObjectType implements SimpleTypeInterface
+{
+    public function __construct(
+        private string $className
+    ) {
+    }
+
+    // exact match only; parent/interface resolution needs static reflection we do not have here
+    public function isInstanceOf(string ...$classNames): bool
+    {
+        return in_array($this->className, $classNames, true);
+    }
+}
diff --git a/src/Analyzer/SimpleType/StringType.php b/src/Analyzer/SimpleType/StringType.php
new file mode 100644
index 00000000000..db00fc44382
--- /dev/null
+++ b/src/Analyzer/SimpleType/StringType.php
@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Analyzer\SimpleType;
+
+use Rector\Analyzer\SimpleType\Contract\SimpleTypeInterface;
+
+final class StringType implements SimpleTypeInterface
+{
+}
diff --git a/src/DependencyInjection/LazyContainerFactory.php b/src/DependencyInjection/LazyContainerFactory.php
index 33d6146a522..d2d92b1fd5e 100644
--- a/src/DependencyInjection/LazyContainerFactory.php
+++ b/src/DependencyInjection/LazyContainerFactory.php
@@ -63,6 +63,7 @@
 use Rector\PhpParser\NodeVisitor\LocalVariableScopeNodeVisitor;
 use Rector\PhpParser\NodeVisitor\NameAndArgNodeVisitor;
 use Rector\PhpParser\NodeVisitor\PhpVersionConditionNodeVisitor;
+use Rector\PhpParser\NodeVisitor\SimpleScopeNodeVisitor;
 use Rector\PHPStanStaticTypeMapper\PHPStanStaticTypeMapper;
 use Rector\PHPStanStaticTypeMapper\TypeMapper\ArrayTypeMapper;
 use Rector\PHPStanStaticTypeMapper\TypeMapper\ConditionalTypeForParameterMapper;
@@ -101,6 +102,7 @@ final class LazyContainerFactory
         LocalVariableScopeNodeVisitor::class,
         NameAndArgNodeVisitor::class,
         DefaultValueNodeVisitor::class,
+        SimpleScopeNodeVisitor::class,
     ];
 
     /**
diff --git a/src/NodeTypeResolver/Node/AttributeKey.php b/src/NodeTypeResolver/Node/AttributeKey.php
index c902a3ae221..83eea8af136 100644
--- a/src/NodeTypeResolver/Node/AttributeKey.php
+++ b/src/NodeTypeResolver/Node/AttributeKey.php
@@ -21,6 +21,11 @@ final class AttributeKey
      */
     public const string SCOPE = 'scope';
 
+    /**
+     * PHPStan-free scope attached by SimpleScopeNodeVisitor
+     */
+    public const string SIMPLE_SCOPE = 'simpleScope';
+
     /**
      * Internal php-parser name.
      * Do not change this even if you want!
diff --git a/src/PhpParser/NodeVisitor/SimpleScopeNodeVisitor.php b/src/PhpParser/NodeVisitor/SimpleScopeNodeVisitor.php
new file mode 100644
index 00000000000..a219728dd83
--- /dev/null
+++ b/src/PhpParser/NodeVisitor/SimpleScopeNodeVisitor.php
@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\PhpParser\NodeVisitor;
+
+use PhpParser\Node;
+use PhpParser\Node\FunctionLike;
+use PhpParser\NodeVisitorAbstract;
+use Rector\Analyzer\SimpleScope\SimpleScopeResolver;
+use Rector\Contract\PhpParser\DecoratingNodeVisitorInterface;
+use Rector\NodeTypeResolver\Node\AttributeKey;
+use Rector\PhpDocParser\NodeTraverser\SimpleCallableNodeTraverser;
+
+/**
+ * Resolves a PHPStan-free SimpleScope per function-like and attaches it to the
+ * statements inside, so rules can read the caller type without walking the tree.
+ */
+final class SimpleScopeNodeVisitor extends NodeVisitorAbstract implements DecoratingNodeVisitorInterface
+{
+    public function __construct(
+        private readonly SimpleScopeResolver $simpleScopeResolver,
+        private readonly SimpleCallableNodeTraverser $simpleCallableNodeTraverser
+    ) {
+    }
+
+    public function enterNode(Node $node): ?Node
+    {
+        if (! $node instanceof FunctionLike) {
+            return null;
+        }
+
+        $stmts = $node->getStmts();
+        if ($stmts === null) {
+            return null;
+        }
+
+        $simpleScope = $this->simpleScopeResolver->resolve([$node]);
+        $this->simpleCallableNodeTraverser->traverseNodesWithCallable($stmts, static function (Node $subNode) use (
+            $simpleScope
+        ): null {
+            $subNode->setAttribute(AttributeKey::SIMPLE_SCOPE, $simpleScope);
+            return null;
+        });
+
+        return null;
+    }
+}
diff --git a/tests/Analyzer/SimpleScope/SimpleScopeResolverTest.php b/tests/Analyzer/SimpleScope/SimpleScopeResolverTest.php
new file mode 100644
index 00000000000..2dd19963ff2
--- /dev/null
+++ b/tests/Analyzer/SimpleScope/SimpleScopeResolverTest.php
@@ -0,0 +1,95 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Tests\Analyzer\SimpleScope;
+
+use PhpParser\Node\Expr\Variable;
+use PhpParser\Node\Scalar\String_;
+use PhpParser\ParserFactory;
+use PHPUnit\Framework\TestCase;
+use Rector\Analyzer\SimpleScope\SimpleScope;
+use Rector\Analyzer\SimpleScope\SimpleScopeResolver;
+use Rector\Analyzer\SimpleType\MixedType;
+use Rector\Analyzer\SimpleType\ObjectType;
+use Rector\Analyzer\SimpleType\StringType;
+
+final class SimpleScopeResolverTest extends TestCase
+{
+    private SimpleScopeResolver $simpleScopeResolver;
+
+    protected function setUp(): void
+    {
+        $this->simpleScopeResolver = new SimpleScopeResolver();
+    }
+
+    public function testResolvesNewAssignToObjectType(): void
+    {
+        $simpleScope = $this->resolveCode(<<<'PHP'
+<?php
+function demo()
+{
+    $dateTime = new \DateTime();
+}
+PHP);
+
+        $simpleType = $simpleScope->getType(new Variable('dateTime'));
+        $this->assertInstanceOf(ObjectType::class, $simpleType);
+        $this->assertTrue($simpleType->isInstanceOf('DateTime'));
+    }
+
+    public function testIsObjectType(): void
+    {
+        $simpleScope = $this->resolveCode(<<<'PHP'
+<?php
+function demo()
+{
+    $dateTime = new \DateTime();
+}
+PHP);
+
+        $this->assertTrue($simpleScope->isObjectType(new Variable('dateTime'), 'DateTime'));
+        $this->assertFalse($simpleScope->isObjectType(new Variable('dateTime'), 'stdClass'));
+        $this->assertFalse($simpleScope->isObjectType(new Variable('missing'), 'DateTime'));
+    }
+
+    public function testResolvesTypedParam(): void
+    {
+        $simpleScope = $this->resolveCode(<<<'PHP'
+<?php
+function demo(string $name)
+{
+}
+PHP);
+
+        $this->assertInstanceOf(StringType::class, $simpleScope->getType(new Variable('name')));
+    }
+
+    public function testUnknownVariableIsMixed(): void
+    {
+        $simpleScope = $this->resolveCode(<<<'PHP'
+<?php
+function demo()
+{
+}
+PHP);
+
+        $this->assertInstanceOf(MixedType::class, $simpleScope->getType(new Variable('missing')));
+    }
+
+    public function testResolvesLiteralType(): void
+    {
+        $simpleScope = $this->resolveCode('<?php');
+
+        $this->assertInstanceOf(StringType::class, $simpleScope->getType(new String_('hello')));
+    }
+
+    private function resolveCode(string $code): SimpleScope
+    {
+        $parser = new ParserFactory()
+            ->createForNewestSupportedVersion();
+        $stmts = $parser->parse($code);
+
+        return $this->simpleScopeResolver->resolve($stmts ?? []);
+    }
+}