diff --git a/rules-tests/Simple/Rector/ClassMethod/DemoObjectMethodCallRenameRector/DemoObjectMethodCallRenameRectorTest.php b/rules-tests/Simple/Rector/ClassMethod/DemoObjectMethodCallRenameRector/DemoObjectMethodCallRenameRectorTest.php
new file mode 100644
index 00000000000..6344ac0d22d
--- /dev/null
+++ b/rules-tests/Simple/Rector/ClassMethod/DemoObjectMethodCallRenameRector/DemoObjectMethodCallRenameRectorTest.php
@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Tests\Simple\Rector\ClassMethod\DemoObjectMethodCallRenameRector;
+
+use Iterator;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Rector\Testing\PHPUnit\AbstractRectorTestCase;
+
+final class DemoObjectMethodCallRenameRectorTest 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/Simple/Rector/ClassMethod/DemoObjectMethodCallRenameRector/Fixture/assigned_new.php.inc b/rules-tests/Simple/Rector/ClassMethod/DemoObjectMethodCallRenameRector/Fixture/assigned_new.php.inc
new file mode 100644
index 00000000000..856d11a191b
--- /dev/null
+++ b/rules-tests/Simple/Rector/ClassMethod/DemoObjectMethodCallRenameRector/Fixture/assigned_new.php.inc
@@ -0,0 +1,29 @@
+<?php
+
+namespace Rector\Tests\Simple\Rector\ClassMethod\DemoObjectMethodCallRenameRector\Fixture;
+
+class AssignedNew
+{
+    public function run()
+    {
+        $dateTime = new \DateTime();
+        $dateTime->oldMethod();
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\Simple\Rector\ClassMethod\DemoObjectMethodCallRenameRector\Fixture;
+
+class AssignedNew
+{
+    public function run()
+    {
+        $dateTime = new \DateTime();
+        $dateTime->newMethod();
+    }
+}
+
+?>
diff --git a/rules-tests/Simple/Rector/ClassMethod/DemoObjectMethodCallRenameRector/Fixture/skip_other_class.php.inc b/rules-tests/Simple/Rector/ClassMethod/DemoObjectMethodCallRenameRector/Fixture/skip_other_class.php.inc
new file mode 100644
index 00000000000..9e6a6690fb4
--- /dev/null
+++ b/rules-tests/Simple/Rector/ClassMethod/DemoObjectMethodCallRenameRector/Fixture/skip_other_class.php.inc
@@ -0,0 +1,12 @@
+<?php
+
+namespace Rector\Tests\Simple\Rector\ClassMethod\DemoObjectMethodCallRenameRector\Fixture;
+
+class SkipOtherClass
+{
+    public function run()
+    {
+        $value = new \stdClass();
+        $value->oldMethod();
+    }
+}
diff --git a/rules-tests/Simple/Rector/ClassMethod/DemoObjectMethodCallRenameRector/Fixture/skip_unknown_variable.php.inc b/rules-tests/Simple/Rector/ClassMethod/DemoObjectMethodCallRenameRector/Fixture/skip_unknown_variable.php.inc
new file mode 100644
index 00000000000..64219656bc2
--- /dev/null
+++ b/rules-tests/Simple/Rector/ClassMethod/DemoObjectMethodCallRenameRector/Fixture/skip_unknown_variable.php.inc
@@ -0,0 +1,11 @@
+<?php
+
+namespace Rector\Tests\Simple\Rector\ClassMethod\DemoObjectMethodCallRenameRector\Fixture;
+
+class SkipUnknownVariable
+{
+    public function run($dateTime)
+    {
+        $dateTime->oldMethod();
+    }
+}
diff --git a/rules-tests/Simple/Rector/ClassMethod/DemoObjectMethodCallRenameRector/Fixture/typed_param.php.inc b/rules-tests/Simple/Rector/ClassMethod/DemoObjectMethodCallRenameRector/Fixture/typed_param.php.inc
new file mode 100644
index 00000000000..f203d30d887
--- /dev/null
+++ b/rules-tests/Simple/Rector/ClassMethod/DemoObjectMethodCallRenameRector/Fixture/typed_param.php.inc
@@ -0,0 +1,27 @@
+<?php
+
+namespace Rector\Tests\Simple\Rector\ClassMethod\DemoObjectMethodCallRenameRector\Fixture;
+
+class TypedParam
+{
+    public function run(\DateTime $dateTime)
+    {
+        $dateTime->oldMethod();
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\Simple\Rector\ClassMethod\DemoObjectMethodCallRenameRector\Fixture;
+
+class TypedParam
+{
+    public function run(\DateTime $dateTime)
+    {
+        $dateTime->newMethod();
+    }
+}
+
+?>
diff --git a/rules-tests/Simple/Rector/ClassMethod/DemoObjectMethodCallRenameRector/config/configured_rule.php b/rules-tests/Simple/Rector/ClassMethod/DemoObjectMethodCallRenameRector/config/configured_rule.php
new file mode 100644
index 00000000000..fcb87975289
--- /dev/null
+++ b/rules-tests/Simple/Rector/ClassMethod/DemoObjectMethodCallRenameRector/config/configured_rule.php
@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+use Rector\Config\RectorConfig;
+use Rector\Simple\Rector\ClassMethod\DemoObjectMethodCallRenameRector;
+
+return static function (RectorConfig $rectorConfig): void {
+    $rectorConfig->rule(DemoObjectMethodCallRenameRector::class);
+};
diff --git a/rules/DeadCode/Rector/ClassMethod/RemoveParentDelegatingClassMethodRector.php b/rules/DeadCode/Rector/ClassMethod/RemoveParentDelegatingClassMethodRector.php
index 50ad208a46a..acf657f6102 100644
--- a/rules/DeadCode/Rector/ClassMethod/RemoveParentDelegatingClassMethodRector.php
+++ b/rules/DeadCode/Rector/ClassMethod/RemoveParentDelegatingClassMethodRector.php
@@ -4,7 +4,6 @@
 
 namespace Rector\DeadCode\Rector\ClassMethod;
 
-use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocChildNode;
 use PhpParser\Node;
 use PhpParser\Node\Expr\StaticCall;
 use PhpParser\Node\Expr\Variable;
@@ -13,6 +12,7 @@
 use PhpParser\Node\Stmt\Expression;
 use PhpParser\Node\Stmt\Return_;
 use PhpParser\NodeVisitor;
+use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocChildNode;
 use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagNode;
 use PHPStan\Reflection\ClassReflection;
 use PHPStan\Reflection\ExtendedMethodReflection;
@@ -117,7 +117,7 @@ public function refactor(Node $node): ?int
     private function hasRefiningDocblock(ClassMethod $classMethod): bool
     {
         $phpDocInfo = $this->phpDocInfoFactory->createFromNodeOrEmpty($classMethod);
-        return array_any($phpDocInfo->getPhpDocNode()->children, fn(PhpDocChildNode $phpDocChildNode): bool => $phpDocChildNode instanceof PhpDocTagNode);
+        return array_any($phpDocInfo->getPhpDocNode()->children, fn (PhpDocChildNode $phpDocChildNode): bool => $phpDocChildNode instanceof PhpDocTagNode);
     }
 
     private function matchParentMethodReflection(ClassMethod $classMethod): ?ExtendedMethodReflection
diff --git a/rules/Simple/Rector/ClassMethod/DemoObjectMethodCallRenameRector.php b/rules/Simple/Rector/ClassMethod/DemoObjectMethodCallRenameRector.php
new file mode 100644
index 00000000000..88fc952d74e
--- /dev/null
+++ b/rules/Simple/Rector/ClassMethod/DemoObjectMethodCallRenameRector.php
@@ -0,0 +1,115 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Simple\Rector\ClassMethod;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Stmt\ClassMethod;
+use Rector\Rector\AbstractRector;
+use Rector\SimpleScope\SimpleScope;
+use Rector\SimpleScope\SimpleScopeResolver;
+use Rector\SimpleType\ObjectType;
+use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
+use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
+
+// POC: type resolution done via SimpleScope, no PHPStan
+/**
+ * @see \Rector\Tests\Simple\Rector\ClassMethod\DemoObjectMethodCallRenameRector\DemoObjectMethodCallRenameRectorTest
+ */
+final class DemoObjectMethodCallRenameRector extends AbstractRector
+{
+    private const string TARGET_CLASS = 'DateTime';
+
+    private const string OLD_METHOD = 'oldMethod';
+
+    private const string NEW_METHOD = 'newMethod';
+
+    public function __construct(
+        private readonly SimpleScopeResolver $simpleScopeResolver
+    ) {
+    }
+
+    public function getRuleDefinition(): RuleDefinition
+    {
+        return new RuleDefinition(
+            'Demo of SimpleScope: rename oldMethod() to newMethod() on DateTime calls, type resolved without PHPStan',
+            [
+                new CodeSample(
+                    <<<'CODE_SAMPLE'
+$dateTime = new DateTime();
+$dateTime->oldMethod();
+CODE_SAMPLE
+                    ,
+                    <<<'CODE_SAMPLE'
+$dateTime = new DateTime();
+$dateTime->newMethod();
+CODE_SAMPLE
+                ),
+            ]
+        );
+    }
+
+    public function getNodeTypes(): array
+    {
+        return [ClassMethod::class];
+    }
+
+    /**
+     * @param ClassMethod $node
+     */
+    public function refactor(Node $node): ?Node
+    {
+        $stmts = $node->stmts;
+        if ($stmts === null) {
+            return null;
+        }
+
+        $simpleScope = $this->simpleScopeResolver->resolve([$node]);
+
+        $hasChanged = false;
+        $this->traverseNodesWithCallable($stmts, function (Node $subNode) use ($simpleScope, &$hasChanged): null {
+            if ($this->refactorMethodCall($subNode, $simpleScope)) {
+                $hasChanged = true;
+            }
+
+            return null;
+        });
+
+        if (! $hasChanged) {
+            return null;
+        }
+
+        return $node;
+    }
+
+    private function refactorMethodCall(Node $node, SimpleScope $simpleScope): bool
+    {
+        if (! $node instanceof MethodCall) {
+            return false;
+        }
+
+        if ($node->isFirstClassCallable()) {
+            return false;
+        }
+
+        if (! $this->isName($node->name, self::OLD_METHOD)) {
+            return false;
+        }
+
+        $simpleType = $simpleScope->getType($node->var);
+        if (! $simpleType instanceof ObjectType) {
+            return false;
+        }
+
+        if ($simpleType->getClassName() !== self::TARGET_CLASS) {
+            return false;
+        }
+
+        $node->name = new Identifier(self::NEW_METHOD);
+
+        return true;
+    }
+}
diff --git a/src/SimpleScope/SimpleScope.php b/src/SimpleScope/SimpleScope.php
new file mode 100644
index 00000000000..5cc84159a05
--- /dev/null
+++ b/src/SimpleScope/SimpleScope.php
@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\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\SimpleType\ArrayType;
+use Rector\SimpleType\BooleanType;
+use Rector\SimpleType\Contract\SimpleTypeInterface;
+use Rector\SimpleType\IntegerType;
+use Rector\SimpleType\MixedType;
+use Rector\SimpleType\NullType;
+use Rector\SimpleType\ObjectType;
+use Rector\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 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/SimpleScope/SimpleScopeResolver.php b/src/SimpleScope/SimpleScopeResolver.php
new file mode 100644
index 00000000000..4d7dc642fb7
--- /dev/null
+++ b/src/SimpleScope/SimpleScopeResolver.php
@@ -0,0 +1,88 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\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\SimpleType\ArrayType;
+use Rector\SimpleType\BooleanType;
+use Rector\SimpleType\Contract\SimpleTypeInterface;
+use Rector\SimpleType\IntegerType;
+use Rector\SimpleType\ObjectType;
+use Rector\SimpleType\StringType;
+
+// builds a PHPStan-free SimpleScope from params and local assigns, in source order
+/**
+ * @see \Rector\Tests\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/SimpleType/ArrayType.php b/src/SimpleType/ArrayType.php
new file mode 100644
index 00000000000..edea4c8a019
--- /dev/null
+++ b/src/SimpleType/ArrayType.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\SimpleType;
+
+use Rector\SimpleType\Contract\SimpleTypeInterface;
+
+final class ArrayType implements SimpleTypeInterface
+{
+    public function describe(): string
+    {
+        return 'array';
+    }
+}
diff --git a/src/SimpleType/BooleanType.php b/src/SimpleType/BooleanType.php
new file mode 100644
index 00000000000..8bbe705412d
--- /dev/null
+++ b/src/SimpleType/BooleanType.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\SimpleType;
+
+use Rector\SimpleType\Contract\SimpleTypeInterface;
+
+final class BooleanType implements SimpleTypeInterface
+{
+    public function describe(): string
+    {
+        return 'bool';
+    }
+}
diff --git a/src/SimpleType/Contract/SimpleTypeInterface.php b/src/SimpleType/Contract/SimpleTypeInterface.php
new file mode 100644
index 00000000000..dae08e8e7ab
--- /dev/null
+++ b/src/SimpleType/Contract/SimpleTypeInterface.php
@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\SimpleType\Contract;
+
+// PHPStan-free type contract, resolved by SimpleScope
+interface SimpleTypeInterface
+{
+    public function describe(): string;
+}
diff --git a/src/SimpleType/IntegerType.php b/src/SimpleType/IntegerType.php
new file mode 100644
index 00000000000..36b3f70b06c
--- /dev/null
+++ b/src/SimpleType/IntegerType.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\SimpleType;
+
+use Rector\SimpleType\Contract\SimpleTypeInterface;
+
+final class IntegerType implements SimpleTypeInterface
+{
+    public function describe(): string
+    {
+        return 'int';
+    }
+}
diff --git a/src/SimpleType/MixedType.php b/src/SimpleType/MixedType.php
new file mode 100644
index 00000000000..81c083d6817
--- /dev/null
+++ b/src/SimpleType/MixedType.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\SimpleType;
+
+use Rector\SimpleType\Contract\SimpleTypeInterface;
+
+final class MixedType implements SimpleTypeInterface
+{
+    public function describe(): string
+    {
+        return 'mixed';
+    }
+}
diff --git a/src/SimpleType/NullType.php b/src/SimpleType/NullType.php
new file mode 100644
index 00000000000..e3b038bf712
--- /dev/null
+++ b/src/SimpleType/NullType.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\SimpleType;
+
+use Rector\SimpleType\Contract\SimpleTypeInterface;
+
+final class NullType implements SimpleTypeInterface
+{
+    public function describe(): string
+    {
+        return 'null';
+    }
+}
diff --git a/src/SimpleType/ObjectType.php b/src/SimpleType/ObjectType.php
new file mode 100644
index 00000000000..c435de6c47d
--- /dev/null
+++ b/src/SimpleType/ObjectType.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\SimpleType;
+
+use Rector\SimpleType\Contract\SimpleTypeInterface;
+
+final readonly class ObjectType implements SimpleTypeInterface
+{
+    public function __construct(
+        private string $className
+    ) {
+    }
+
+    public function describe(): string
+    {
+        return $this->className;
+    }
+
+    public function getClassName(): string
+    {
+        return $this->className;
+    }
+}
diff --git a/src/SimpleType/StringType.php b/src/SimpleType/StringType.php
new file mode 100644
index 00000000000..0940c8e60b8
--- /dev/null
+++ b/src/SimpleType/StringType.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\SimpleType;
+
+use Rector\SimpleType\Contract\SimpleTypeInterface;
+
+final class StringType implements SimpleTypeInterface
+{
+    public function describe(): string
+    {
+        return 'string';
+    }
+}
diff --git a/tests/SimpleScope/SimpleScopeResolverTest.php b/tests/SimpleScope/SimpleScopeResolverTest.php
new file mode 100644
index 00000000000..87571000eaf
--- /dev/null
+++ b/tests/SimpleScope/SimpleScopeResolverTest.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Tests\SimpleScope;
+
+use PhpParser\Node\Expr\Variable;
+use PhpParser\Node\Scalar\String_;
+use PhpParser\ParserFactory;
+use PHPUnit\Framework\TestCase;
+use Rector\SimpleScope\SimpleScope;
+use Rector\SimpleScope\SimpleScopeResolver;
+
+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);
+
+        $this->assertSame('DateTime', $simpleScope->getType(new Variable('dateTime'))->describe());
+    }
+
+    public function testResolvesTypedParam(): void
+    {
+        $simpleScope = $this->resolveCode(<<<'PHP'
+<?php
+function demo(string $name)
+{
+}
+PHP);
+
+        $this->assertSame('string', $simpleScope->getType(new Variable('name'))->describe());
+    }
+
+    public function testUnknownVariableIsMixed(): void
+    {
+        $simpleScope = $this->resolveCode(<<<'PHP'
+<?php
+function demo()
+{
+}
+PHP);
+
+        $this->assertSame('mixed', $simpleScope->getType(new Variable('missing'))->describe());
+    }
+
+    public function testResolvesLiteralType(): void
+    {
+        $simpleScope = $this->resolveCode('<?php');
+
+        $this->assertSame('string', $simpleScope->getType(new String_('hello'))->describe());
+    }
+
+    private function resolveCode(string $code): SimpleScope
+    {
+        $parser = new ParserFactory()->createForNewestSupportedVersion();
+        $stmts = $parser->parse($code);
+
+        return $this->simpleScopeResolver->resolve($stmts ?? []);
+    }
+}