diff --git a/rector.php b/rector.php
index 4a6d3db3656..47dd720db67 100644
--- a/rector.php
+++ b/rector.php
@@ -7,6 +7,7 @@
 use Rector\DeadCode\Rector\ConstFetch\RemovePhpVersionIdCheckRector;
 use Rector\DeadCode\Rector\Property\RemoveUnusedPrivatePropertyRector;
 use Rector\Php55\Rector\String_\StringClassNameToClassConstantRector;
+use Rector\TypeDeclaration\Rector\Expression\InlineVarDocTagToAssertRector;
 
 return RectorConfig::configure()
     ->withPreparedSets(
@@ -57,4 +58,5 @@
         ],
 
         RemoveUnusedPrivatePropertyRector::class => [__DIR__ . '/src/Configuration/RectorConfigBuilder.php'],
+        InlineVarDocTagToAssertRector::class,
     ]);
diff --git a/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_all_basic_types.php.inc b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_all_basic_types.php.inc
new file mode 100644
index 00000000000..c64d0726b62
--- /dev/null
+++ b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_all_basic_types.php.inc
@@ -0,0 +1,73 @@
+<?php
+
+/** @var false $foo */
+$foo = getFalse();
+
+/** @var true $foo */
+$foo = getTrue();
+
+/** @var string $foo */
+$foo = getString();
+
+/** @var float $foo */
+$foo = getFloat();
+
+/** @var int $foo */
+$foo = getInt();
+
+/** @var bool $foo */
+$foo = getBool();
+
+/** @var null $foo */
+$foo = getNull();
+
+/** @var callable $foo */
+$foo = getCallable();
+
+/** @var object $foo */
+$foo = getObject();
+
+/** @var array $foo */
+$foo = getArray();
+
+/** @var iterable $foo */
+$foo = getIterable();
+
+?>
+-----
+<?php
+
+$foo = getFalse();
+assert($foo === false);
+
+$foo = getTrue();
+assert($foo === true);
+
+$foo = getString();
+assert(is_string($foo));
+
+$foo = getFloat();
+assert(is_float($foo));
+
+$foo = getInt();
+assert(is_int($foo));
+
+$foo = getBool();
+assert(is_bool($foo));
+
+$foo = getNull();
+assert($foo === null);
+
+$foo = getCallable();
+assert(is_callable($foo));
+
+$foo = getObject();
+assert(is_object($foo));
+
+$foo = getArray();
+assert(is_array($foo));
+
+$foo = getIterable();
+assert(is_iterable($foo));
+
+?>
diff --git a/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_classes_and_interfaces.php.inc b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_classes_and_interfaces.php.inc
new file mode 100644
index 00000000000..be9bfb083a6
--- /dev/null
+++ b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_classes_and_interfaces.php.inc
@@ -0,0 +1,43 @@
+<?php
+
+namespace Rector\Tests\TypeDeclaration\Rector\Expression\InlineVarDocTagToAssertRector\Fixture;
+
+use Foo\Bar;
+use Rector\Tests\Renaming\Rector\MethodCall\RenameMethodRector\Source\FooInterface;
+use Traversable;
+
+/** @var Bar $foo */
+$foo = getBar();
+
+/** @var \Foo\Bar $foo */
+$foo = getFooBar();
+
+/** @var FooInterface $foo */
+$foo = getFooInterface();
+
+/** @var Traversable $foo */
+$foo = getTraversable();
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\TypeDeclaration\Rector\Expression\InlineVarDocTagToAssertRector\Fixture;
+
+use Foo\Bar;
+use Rector\Tests\Renaming\Rector\MethodCall\RenameMethodRector\Source\FooInterface;
+use Traversable;
+
+$foo = getBar();
+assert($foo instanceof Bar);
+
+$foo = getFooBar();
+assert($foo instanceof \Foo\Bar);
+
+$foo = getFooInterface();
+assert($foo instanceof FooInterface);
+
+$foo = getTraversable();
+assert($foo instanceof Traversable);
+
+?>
diff --git a/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_intersection_types.php.inc b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_intersection_types.php.inc
new file mode 100644
index 00000000000..d37b309a5bb
--- /dev/null
+++ b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_intersection_types.php.inc
@@ -0,0 +1,19 @@
+<?php
+
+/** @var Foo&Bar $foo */
+$foo = getFooAndBar();
+
+/** @var \Foo&\Bar $foo */
+$foo = getFooAndBar();
+
+?>
+-----
+<?php
+
+$foo = getFooAndBar();
+assert($foo instanceof Foo && $foo instanceof Bar);
+
+$foo = getFooAndBar();
+assert($foo instanceof \Foo && $foo instanceof \Bar);
+
+?>
diff --git a/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_nullable_types.php.inc b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_nullable_types.php.inc
new file mode 100644
index 00000000000..01690e8c85b
--- /dev/null
+++ b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_nullable_types.php.inc
@@ -0,0 +1,19 @@
+<?php
+
+/** @var ?string $foo */
+$foo = getNullableString();
+
+/** @var ?Foo $foo */
+$foo = getNullableFoo();
+
+?>
+-----
+<?php
+
+$foo = getNullableString();
+assert(is_string($foo) || $foo === null);
+
+$foo = getNullableFoo();
+assert($foo instanceof Foo || $foo === null);
+
+?>
diff --git a/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_self_static_and_parent.php.inc b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_self_static_and_parent.php.inc
new file mode 100644
index 00000000000..64f0e9ff54e
--- /dev/null
+++ b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_self_static_and_parent.php.inc
@@ -0,0 +1,45 @@
+<?php
+
+namespace Rector\Tests\TypeDeclaration\Rector\Expression\InlineVarDocTagToAssertRector\Fixture;
+
+class OtherClass {}
+
+class SomeClass extends OtherClass
+{
+    function test()
+    {
+        /** @var self $foo */
+        $foo = getSelf();
+
+        /** @var static $foo */
+        $foo = getStatic();
+
+        /** @var parent $foo */
+        $foo = getParent();
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\TypeDeclaration\Rector\Expression\InlineVarDocTagToAssertRector\Fixture;
+
+class OtherClass {}
+
+class SomeClass extends OtherClass
+{
+    function test()
+    {
+        $foo = getSelf();
+        assert($foo instanceof self);
+
+        $foo = getStatic();
+        assert($foo instanceof static);
+
+        $foo = getParent();
+        assert($foo instanceof parent);
+    }
+}
+
+?>
diff --git a/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_union_types.php.inc b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_union_types.php.inc
new file mode 100644
index 00000000000..9c41cac7860
--- /dev/null
+++ b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_union_types.php.inc
@@ -0,0 +1,43 @@
+<?php
+
+/** @var string|false $foo */
+$foo = getStringOrFalse();
+
+/** @var string|int|null $foo */
+$foo = getStringOrFalse();
+
+/** @var int|float|bool|string|array $foo */
+$foo = getMultipleTypes();
+
+/** @var string|Foo $foo */
+$foo = getStringOrFoo();
+
+/** @var Foo|Bar $foo */
+$foo = getFooOrBar();
+
+/** @var \Foo|\Bar $foo */
+$foo = getFooOrBar();
+
+?>
+-----
+<?php
+
+$foo = getStringOrFalse();
+assert(is_string($foo) || $foo === false);
+
+$foo = getStringOrFalse();
+assert(is_string($foo) || is_int($foo) || $foo === null);
+
+$foo = getMultipleTypes();
+assert(is_int($foo) || is_float($foo) || is_bool($foo) || is_string($foo) || is_array($foo));
+
+$foo = getStringOrFoo();
+assert(is_string($foo) || $foo instanceof Foo);
+
+$foo = getFooOrBar();
+assert($foo instanceof Foo || $foo instanceof Bar);
+
+$foo = getFooOrBar();
+assert($foo instanceof \Foo || $foo instanceof \Bar);
+
+?>
diff --git a/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_variable_in_some_function.php.inc b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_variable_in_some_function.php.inc
new file mode 100644
index 00000000000..92586d4f03e
--- /dev/null
+++ b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_variable_in_some_function.php.inc
@@ -0,0 +1,21 @@
+<?php
+
+namespace Rector\Tests\TypeDeclaration\Rector\Expression\InlineVarDocTagToAssertRector\Fixture;
+
+function test() {
+    /** @var string $foo */
+    $foo = getString();
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\TypeDeclaration\Rector\Expression\InlineVarDocTagToAssertRector\Fixture;
+
+function test() {
+    $foo = getString();
+    assert(is_string($foo));
+}
+
+?>
diff --git a/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_variable_in_some_method.php.inc b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_variable_in_some_method.php.inc
new file mode 100644
index 00000000000..e2a99b9c8fe
--- /dev/null
+++ b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/convert_variable_in_some_method.php.inc
@@ -0,0 +1,27 @@
+<?php
+
+namespace Rector\Tests\TypeDeclaration\Rector\Expression\InlineVarDocTagToAssertRector\Fixture;
+
+final class SomeClass
+{
+    function test() {
+        /** @var string $foo */
+        $foo = getString();
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\TypeDeclaration\Rector\Expression\InlineVarDocTagToAssertRector\Fixture;
+
+final class SomeClass
+{
+    function test() {
+        $foo = getString();
+        assert(is_string($foo));
+    }
+}
+
+?>
diff --git a/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/preserve_comments.php.inc b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/preserve_comments.php.inc
new file mode 100644
index 00000000000..c32ec25508d
--- /dev/null
+++ b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/preserve_comments.php.inc
@@ -0,0 +1,77 @@
+<?php
+
+/**
+ * @var string $foo
+ * This is the string
+ */
+$foo = getString();
+
+/**
+ * We are going to do something
+ * @var string $foo
+ */
+$foo = getString();
+
+/**
+ * @var string $foo
+ * @deprecated
+ */
+$foo = getString();
+
+/**
+ * @var string $foo
+ * @see getStringTest()
+ * Please do not change
+ */
+$foo = getString();
+
+/**
+ * @var string $foo
+ * @var int $bar
+ */
+$foo = getString();
+$bar = getInt();
+
+/** @var string $foo this is the string */
+$foo = getString();
+
+?>
+-----
+<?php
+
+/**
+ * @var string $foo
+ * This is the string
+ */
+$foo = getString();
+
+/**
+ * We are going to do something
+ */
+$foo = getString();
+assert(is_string($foo));
+
+/**
+ * @deprecated
+ */
+$foo = getString();
+assert(is_string($foo));
+
+/**
+ * @see getStringTest()
+ * Please do not change
+ */
+$foo = getString();
+assert(is_string($foo));
+
+/**
+ * @var int $bar
+ */
+$foo = getString();
+assert(is_string($foo));
+$bar = getInt();
+
+/** @var string $foo this is the string */
+$foo = getString();
+
+?>
diff --git a/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_complex_types.php.inc b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_complex_types.php.inc
new file mode 100644
index 00000000000..2e787e5fa74
--- /dev/null
+++ b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_complex_types.php.inc
@@ -0,0 +1,11 @@
+<?php
+
+/** @var array<string> $foo */
+$foo = getArrayOfString();
+
+/** @var string[] $foo */
+$foo = getArrayOfString();
+
+/** @var Collection<Foo> $foo */
+$foo = getCollection();
+
diff --git a/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_incorrect_php_docs.php.inc b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_incorrect_php_docs.php.inc
new file mode 100644
index 00000000000..96bd7fce826
--- /dev/null
+++ b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_incorrect_php_docs.php.inc
@@ -0,0 +1,18 @@
+<?php
+
+/** @var string */
+$foo = getString();
+
+/* @var string $foo */
+$foo = getString();
+
+/** @param string $foo */
+$foo = getString();
+
+/** @var string $bar */
+$foo = getString();
+
+/** @var string $foo */
+$bar = getString();
+$foo = getString();
+
diff --git a/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_intersections_with_complex_types.php.inc b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_intersections_with_complex_types.php.inc
new file mode 100644
index 00000000000..ee1278621ac
--- /dev/null
+++ b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_intersections_with_complex_types.php.inc
@@ -0,0 +1,5 @@
+<?php
+
+/** @var Foo&Collection<Foo> $foo */
+$foo = getFooAndCollection();
+
diff --git a/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_nullable_complex_types.php.inc b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_nullable_complex_types.php.inc
new file mode 100644
index 00000000000..d15ef550ed2
--- /dev/null
+++ b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_nullable_complex_types.php.inc
@@ -0,0 +1,11 @@
+<?php
+
+/** @var ?array<string> $foo */
+$foo = getArrayOfString();
+
+/** @var ?string[] $foo */
+$foo = getArrayOfString();
+
+/** @var ?Collection<Foo> $foo */
+$foo = getCollection();
+
diff --git a/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_some_basic_narrowed_types.php.inc b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_some_basic_narrowed_types.php.inc
new file mode 100644
index 00000000000..c8d97a15212
--- /dev/null
+++ b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_some_basic_narrowed_types.php.inc
@@ -0,0 +1,14 @@
+<?php
+
+/** @var non-empty-string $foo */
+$foo = getNonEmptyString();
+
+/** @var class-string $foo */
+$foo = getClassString();
+
+/** @var positive-int $foo */
+$foo = getPositiveInt();
+
+/** @var negative-int $foo */
+$foo = getNegativeInt();
+
diff --git a/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_some_basic_types.php.inc b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_some_basic_types.php.inc
new file mode 100644
index 00000000000..7e9e3b1b4a0
--- /dev/null
+++ b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_some_basic_types.php.inc
@@ -0,0 +1,14 @@
+<?php
+
+/** @var void $foo */
+$foo = getVoid();
+
+/** @var resource $foo */
+$foo = getResource();
+
+/** @var never $foo */
+$foo = getNever();
+
+/** @var mixed $foo */
+$foo = getMixed();
+
diff --git a/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_tag_in_property.php.inc b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_tag_in_property.php.inc
new file mode 100644
index 00000000000..78594809cf8
--- /dev/null
+++ b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_tag_in_property.php.inc
@@ -0,0 +1,11 @@
+<?php
+
+namespace Rector\Tests\TypeDeclaration\Rector\Expression\InlineVarDocTagToAssertRector\Fixture;
+
+final class SomeClass
+{
+    /**
+     * @var string $foo
+     */
+    private string $foo;
+}
diff --git a/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_unions_with_complex_types.php.inc b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_unions_with_complex_types.php.inc
new file mode 100644
index 00000000000..df5d4395810
--- /dev/null
+++ b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/Fixture/skip_unions_with_complex_types.php.inc
@@ -0,0 +1,14 @@
+<?php
+
+/** @var array<string>|false $foo */
+$foo = getArrayOfString();
+
+/** @var string[]|null $foo */
+$foo = getArrayOfString();
+
+/** @var string|Collection<Foo> $foo */
+$foo = getCollection();
+
+/** @var array<Foo>|Collection<Foo> $foo */
+$foo = getCollectionOrArray();
+
diff --git a/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/InlineVarDocTagToAssertRectorTest.php b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/InlineVarDocTagToAssertRectorTest.php
new file mode 100644
index 00000000000..2627bf49724
--- /dev/null
+++ b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/InlineVarDocTagToAssertRectorTest.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Tests\TypeDeclaration\Rector\Expression\InlineVarDocTagToAssertRector;
+
+use Iterator;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Rector\Testing\PHPUnit\AbstractRectorTestCase;
+
+final class InlineVarDocTagToAssertRectorTest extends AbstractRectorTestCase
+{
+    #[DataProvider('provideData')]
+    public function test(string $filePath): void
+    {
+        $this->doTestFile($filePath);
+    }
+
+    /**
+     * @return Iterator<string>
+     */
+    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/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/config/configured_rule.php b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/config/configured_rule.php
new file mode 100644
index 00000000000..951809d2aab
--- /dev/null
+++ b/rules-tests/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector/config/configured_rule.php
@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+use Rector\Config\RectorConfig;
+use Rector\TypeDeclaration\Rector\Expression\InlineVarDocTagToAssertRector;
+use Rector\ValueObject\PhpVersionFeature;
+
+return static function (RectorConfig $rectorConfig): void {
+    $rectorConfig->phpVersion(PhpVersionFeature::STRING_IN_ASSERT_ARG);
+    $rectorConfig->rule(InlineVarDocTagToAssertRector::class);
+};
diff --git a/rules/TypeDeclaration/PhpDocParser/TypeExpressionFromVarTagResolver.php b/rules/TypeDeclaration/PhpDocParser/TypeExpressionFromVarTagResolver.php
new file mode 100644
index 00000000000..43b817a8f74
--- /dev/null
+++ b/rules/TypeDeclaration/PhpDocParser/TypeExpressionFromVarTagResolver.php
@@ -0,0 +1,154 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\TypeDeclaration\PhpDocParser;
+
+use PhpParser\Node\Arg;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\BinaryOp\BooleanAnd;
+use PhpParser\Node\Expr\BinaryOp\BooleanOr;
+use PhpParser\Node\Expr\BinaryOp\Identical;
+use PhpParser\Node\Expr\ConstFetch;
+use PhpParser\Node\Expr\FuncCall;
+use PhpParser\Node\Expr\Instanceof_;
+use PhpParser\Node\Expr\Variable;
+use PhpParser\Node\Name;
+use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode;
+use PHPStan\PhpDocParser\Ast\Type\NullableTypeNode;
+use PHPStan\PhpDocParser\Ast\Type\TypeNode;
+use PHPStan\Type\ArrayType;
+use PHPStan\Type\BooleanType;
+use PHPStan\Type\CallableType;
+use PHPStan\Type\Constant\ConstantBooleanType;
+use PHPStan\Type\FloatType;
+use PHPStan\Type\IntegerType;
+use PHPStan\Type\IterableType;
+use PHPStan\Type\MixedType;
+use PHPStan\Type\NullType;
+use PHPStan\Type\ObjectWithoutClassType;
+use PHPStan\Type\StringType;
+use Rector\BetterPhpDocParser\ValueObject\Type\BracketsAwareIntersectionTypeNode;
+use Rector\BetterPhpDocParser\ValueObject\Type\BracketsAwareUnionTypeNode;
+use Rector\StaticTypeMapper\Mapper\ScalarStringToTypeMapper;
+
+final readonly class TypeExpressionFromVarTagResolver
+{
+    public function __construct(
+        private ScalarStringToTypeMapper $scalarStringToTypeMapper
+    ) {
+    }
+
+    public function resolveTypeExpressionFromVarTag(TypeNode $typeNode, Variable $variable): Expr|false
+    {
+        if ($typeNode instanceof IdentifierTypeNode) {
+            $scalarType = $this->scalarStringToTypeMapper->mapScalarStringToType($typeNode->name);
+            $scalarTypeFunction = $this->getScalarTypeFunction($scalarType::class);
+            if ($scalarTypeFunction !== null) {
+                $arg = new Arg($variable);
+                return new FuncCall(new Name($scalarTypeFunction), [$arg]);
+            }
+
+            if ($scalarType instanceof NullType) {
+                return new Identical($variable, new ConstFetch(new Name('null')));
+            }
+
+            if ($scalarType instanceof ConstantBooleanType) {
+                return new Identical(
+                    $variable,
+                    new ConstFetch(new Name($scalarType->getValue() ? 'true' : 'false'))
+                );
+            }
+
+            if ($scalarType instanceof MixedType && ! $scalarType->isExplicitMixed()) {
+                return new Instanceof_($variable, new Name($typeNode->name));
+            }
+        } elseif ($typeNode instanceof NullableTypeNode) {
+            $unionExpressions = [];
+            $nullableTypeExpression = $this->resolveTypeExpressionFromVarTag($typeNode->type, $variable);
+            if ($nullableTypeExpression === false) {
+                return false;
+            }
+
+            $unionExpressions[] = $nullableTypeExpression;
+            $nullExpression = $this->resolveTypeExpressionFromVarTag(new IdentifierTypeNode('null'), $variable);
+            assert($nullExpression !== false);
+            $unionExpressions[] = $nullExpression;
+            return $this->generateOrExpression($unionExpressions);
+        } elseif ($typeNode instanceof BracketsAwareUnionTypeNode) {
+            $unionExpressions = [];
+            foreach ($typeNode->types as $typeNode) {
+                $unionExpression = $this->resolveTypeExpressionFromVarTag($typeNode, $variable);
+                if ($unionExpression === false) {
+                    return false;
+                }
+
+                $unionExpressions[] = $unionExpression;
+            }
+
+            return $this->generateOrExpression($unionExpressions);
+        } elseif ($typeNode instanceof BracketsAwareIntersectionTypeNode) {
+            $intersectionExpressions = [];
+            foreach ($typeNode->types as $typeNode) {
+                $intersectionExpression = $this->resolveTypeExpressionFromVarTag($typeNode, $variable);
+                if ($intersectionExpression === false) {
+                    return false;
+                }
+
+                $intersectionExpressions[] = $intersectionExpression;
+            }
+
+            return $this->generateAndExpression($intersectionExpressions);
+        }
+
+        return false;
+    }
+
+    /**
+     * @param Expr[] $unionExpressions
+     * @return BooleanOr
+     */
+    private function generateOrExpression(array $unionExpressions)
+    {
+        $booleanOr = new BooleanOr($unionExpressions[0], $unionExpressions[1]);
+        if (count($unionExpressions) == 2) {
+            return $booleanOr;
+        }
+
+        array_splice($unionExpressions, 0, 2, [$booleanOr]);
+        return $this->generateOrExpression($unionExpressions);
+    }
+
+    /**
+     * @param Expr[] $intersectionExpressions
+     * @return BooleanAnd
+     */
+    private function generateAndExpression(array $intersectionExpressions)
+    {
+        $booleanAnd = new BooleanAnd($intersectionExpressions[0], $intersectionExpressions[1]);
+        if (count($intersectionExpressions) == 2) {
+            return $booleanAnd;
+        }
+
+        array_splice($intersectionExpressions, 0, 2, [$booleanAnd]);
+        return $this->generateAndExpression($intersectionExpressions);
+    }
+
+    /**
+     * @param class-string $className
+     */
+    private function getScalarTypeFunction(string $className): ?string
+    {
+        return match ($className) {
+            IntegerType::class => 'is_int',
+            BooleanType::class => 'is_bool',
+            FloatType::class => 'is_float',
+            StringType::class => 'is_string',
+            ArrayType::class => 'is_array',
+            CallableType::class => 'is_callable',
+            ObjectWithoutClassType::class => 'is_object',
+            IterableType::class => 'is_iterable',
+            default => null,
+        };
+    }
+}
diff --git a/rules/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector.php b/rules/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector.php
new file mode 100644
index 00000000000..476b00488ed
--- /dev/null
+++ b/rules/TypeDeclaration/Rector/Expression/InlineVarDocTagToAssertRector.php
@@ -0,0 +1,130 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\TypeDeclaration\Rector\Expression;
+
+use PhpParser\Comment\Doc;
+use PhpParser\Node;
+use PhpParser\Node\Arg;
+use PhpParser\Node\Expr\Assign;
+use PhpParser\Node\Expr\FuncCall;
+use PhpParser\Node\Expr\Variable;
+use PhpParser\Node\Name;
+use PhpParser\Node\Stmt\Expression;
+use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagNode;
+use PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode;
+use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfo;
+use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory;
+use Rector\BetterPhpDocParser\PhpDocManipulator\PhpDocTagRemover;
+use Rector\Comments\NodeDocBlock\DocBlockUpdater;
+use Rector\NodeTypeResolver\Node\AttributeKey;
+use Rector\Rector\AbstractRector;
+use Rector\TypeDeclaration\PhpDocParser\TypeExpressionFromVarTagResolver;
+use Rector\ValueObject\PhpVersionFeature;
+use Rector\VersionBonding\Contract\MinPhpVersionInterface;
+use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
+use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
+
+/**
+ * @see \Rector\Tests\TypeDeclaration\Rector\Expression\InlineVarDocTagToAssertRector\InlineVarDocTagToAssertRectorTest
+ */
+final class InlineVarDocTagToAssertRector extends AbstractRector implements MinPhpVersionInterface
+{
+    public function __construct(
+        private readonly PhpDocInfoFactory $phpDocInfoFactory,
+        private readonly PhpDocTagRemover $phpDocTagRemover,
+        private readonly DocBlockUpdater $docBlockUpdater,
+        private readonly TypeExpressionFromVarTagResolver $typeExpressionFromVarTagResolver
+    ) {
+    }
+
+    public function getRuleDefinition(): RuleDefinition
+    {
+        return new RuleDefinition('Convert inline @var tags to calls to assert()', [
+            new CodeSample(
+                <<<'CODE_SAMPLE'
+/** @var Foo $foo */
+$foo = createFoo();
+CODE_SAMPLE
+
+                ,
+                <<<'CODE_SAMPLE'
+$foo = createFoo();
+assert($foo instanceof Foo);
+CODE_SAMPLE
+            ),
+        ]);
+    }
+
+    /**
+     * @return array<class-string<Node>>
+     */
+    public function getNodeTypes(): array
+    {
+        return [Expression::class];
+    }
+
+    /**
+     * @param Expression $node
+     * @return Node[]|null
+     */
+    public function refactor(Node $node): ?array
+    {
+        if (! $node->expr instanceof Assign) {
+            return null;
+        }
+
+        if (! $node->expr->var instanceof Variable) {
+            return null;
+        }
+
+        $docComment = $node->getDocComment();
+        if (! $docComment instanceof Doc) {
+            return null;
+        }
+
+        $phpDocInfo = $this->phpDocInfoFactory->createFromNode($node);
+
+        if (! $phpDocInfo instanceof PhpDocInfo || $phpDocInfo->getPhpDocNode()->children === []) {
+            return null;
+        }
+
+        $expressionVariableName = $node->expr->var->name;
+        foreach ($phpDocInfo->getPhpDocNode()->children as $phpDocChildNode) {
+            if (! $phpDocChildNode instanceof PhpDocTagNode) {
+                continue;
+            }
+
+            $tagValueNode = $phpDocChildNode->value;
+            // handle only basic types, keep phpstan/psalm helper ones
+            if ($tagValueNode instanceof VarTagValueNode && $phpDocChildNode->name === '@var') {
+                //remove $ from variable name
+                $variableName = substr($tagValueNode->variableName, 1);
+                if ($variableName === $expressionVariableName && $tagValueNode->description === '') {
+                    $typeExpression = $this->typeExpressionFromVarTagResolver->resolveTypeExpressionFromVarTag(
+                        $tagValueNode->type,
+                        new Variable($variableName)
+                    );
+                    if ($typeExpression !== false) {
+                        $this->phpDocTagRemover->removeTagValueFromNode($phpDocInfo, $tagValueNode);
+                        $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($node);
+                        $node->setAttribute(AttributeKey::DO_NOT_CHANGE, true);
+
+                        $arg = new Arg($typeExpression);
+                        $funcCall = new FuncCall(new Name('assert'), [$arg]);
+                        $expression = new Expression($funcCall);
+                        return [$node, $expression];
+                    }
+                }
+            }
+        }
+
+        return null;
+    }
+
+    public function provideMinPhpVersion(): int
+    {
+        return PhpVersionFeature::STRING_IN_ASSERT_ARG;
+    }
+}
diff --git a/src/Config/Level/TypeDeclarationLevel.php b/src/Config/Level/TypeDeclarationLevel.php
index 2ebbfd23a98..59b11f5170d 100644
--- a/src/Config/Level/TypeDeclarationLevel.php
+++ b/src/Config/Level/TypeDeclarationLevel.php
@@ -48,6 +48,7 @@
 use Rector\TypeDeclaration\Rector\Closure\AddClosureVoidReturnTypeWhereNoReturnRector;
 use Rector\TypeDeclaration\Rector\Closure\ClosureReturnTypeRector;
 use Rector\TypeDeclaration\Rector\Empty_\EmptyOnNullableObjectToInstanceOfRector;
+use Rector\TypeDeclaration\Rector\Expression\InlineVarDocTagToAssertRector;
 use Rector\TypeDeclaration\Rector\Function_\AddFunctionVoidReturnTypeWhereNoReturnRector;
 use Rector\TypeDeclaration\Rector\FunctionLike\AddParamTypeSplFixedArrayRector;
 use Rector\TypeDeclaration\Rector\FunctionLike\AddReturnTypeDeclarationFromYieldsRector;
@@ -134,5 +135,6 @@ final class TypeDeclarationLevel
         StrictArrayParamDimFetchRector::class,
         StrictStringParamConcatRector::class,
         TypedPropertyFromJMSSerializerAttributeTypeRector::class,
+        InlineVarDocTagToAssertRector::class,
     ];
 }
diff --git a/src/Rector/AbstractRector.php b/src/Rector/AbstractRector.php
index 80a7a9d0a77..1f76add243a 100644
--- a/src/Rector/AbstractRector.php
+++ b/src/Rector/AbstractRector.php
@@ -263,6 +263,10 @@ protected function mirrorComments(Node $newNode, Node $oldNode): void
             return;
         }
 
+        if ($newNode->getAttribute(AttributeKey::DO_NOT_CHANGE) === true) {
+            return;
+        }
+
         $newNode->setAttribute(AttributeKey::PHP_DOC_INFO, $oldNode->getAttribute(AttributeKey::PHP_DOC_INFO));
         if (! $newNode instanceof Nop) {
             $newNode->setAttribute(AttributeKey::COMMENTS, $oldNode->getAttribute(AttributeKey::COMMENTS));