@@ -64,9 +64,6 @@ public function processNode(Node $node, Scope $scope): array
 }
 
 $className = $class->getName();
-if ($objectManager->getMetadataFactory()->isTransient($className)) {
-return [];
-}
 
 try {
 $metadata = $objectManager->getClassMetadata($className);

@@ -0,0 +1,87 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Doctrine\ORM;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\MissingPropertyFromReflectionException;
+use PHPStan\Rules\Rule;
+use PHPStan\Type\Doctrine\ObjectMetadataResolver;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\TypeCombinator;
+use PHPStan\Type\VerbosityLevel;
+use function sprintf;
+
+/**
+* @implements Rule<Node\Stmt\PropertyProperty>
+*/
+class EntityEmbeddableRule implements Rule
+{
+
+/** @var \PHPStan\Type\Doctrine\ObjectMetadataResolver */
+private $objectMetadataResolver;
+
+public function __construct(ObjectMetadataResolver $objectMetadataResolver)
+{
+$this->objectMetadataResolver = $objectMetadataResolver;
+}
+
+public function getNodeType(): string
+{
+return Node\Stmt\PropertyProperty::class;
+}
+
+public function processNode(Node $node, Scope $scope): array
+{
+$class = $scope->getClassReflection();
+if ($class === null) {
+return [];
+}
+
+$objectManager = $this->objectMetadataResolver->getObjectManager();
+if ($objectManager === null) {
+return [];
+}
+
+$className = $class->getName();
+
+try {
+$metadata = $objectManager->getClassMetadata($className);
+} catch (\Doctrine\ORM\Mapping\MappingException $e) {
+return [];
+}
+
+$classMetadataInfo = 'Doctrine\ORM\Mapping\ClassMetadataInfo';
+if (!$metadata instanceof $classMetadataInfo) {
+return [];
+}
+
+$propertyName = (string) $node->name;
+try {
+$property = $class->getNativeProperty($propertyName);
+} catch (MissingPropertyFromReflectionException $e) {
+return [];
+}
+
+if (!isset($metadata->embeddedClasses[$propertyName])) {
+return [];
+}
+
+$errors = [];
+$embeddedClass = $metadata->embeddedClasses[$propertyName];
+$propertyWritableType = $property->getWritableType();
+$accordingToMapping = new ObjectType($embeddedClass['class']);
+if (!TypeCombinator::removeNull($propertyWritableType)->equals($accordingToMapping)) {
+$errors[] = sprintf(
+'Property %s::$%s type mapping mismatch: mapping specifies %s but property expects %s.',
+$class->getName(),
+$propertyName,
+$accordingToMapping->describe(VerbosityLevel::typeOnly()),
+$propertyWritableType->describe(VerbosityLevel::typeOnly())
+);
+}
+
+return $errors;
+}
+
+}

@@ -153,6 +153,21 @@ public function testCustomType(): void
 ]);
 }
 
+public function testEmbeddable(): void
+{
+$this->analyse([__DIR__ . '/data/Embeddable.php'], []);
+}
+
+public function testBrokenEmbeddable(): void
+{
+$this->analyse([__DIR__ . '/data/BrokenEmbeddable.php'], [
+[
+'Property PHPStan\Rules\Doctrine\ORM\BrokenEmbeddable::$one type mapping mismatch: database can contain string|null but property expects string.',
+16,
+],
+]);
+}
+
 public function testUnknownType(): void
 {
 $this->analyse([__DIR__ . '/data/EntityWithUnknownType.php'], [

@@ -0,0 +1,37 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Doctrine\ORM;
+
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+use PHPStan\Type\Doctrine\ObjectMetadataResolver;
+
+/**
+* @extends RuleTestCase<EntityEmbeddableRule>
+*/
+class EntityEmbeddableRuleTest extends RuleTestCase
+{
+
+protected function getRule(): Rule
+{
+return new EntityEmbeddableRule(
+new ObjectMetadataResolver(__DIR__ . '/entity-manager.php', null)
+);
+}
+
+public function testEmbedded(): void
+{
+$this->analyse([__DIR__ . '/data/EntityWithEmbeddable.php'], []);
+}
+
+public function testEmbeddedWithWrongTypeHint(): void
+{
+$this->analyse([__DIR__ . '/data/EntityWithBrokenEmbeddable.php'], [
+[
+'Property PHPStan\Rules\Doctrine\ORM\EntityWithBrokenEmbeddable::$embedded type mapping mismatch: mapping specifies PHPStan\Rules\Doctrine\ORM\Embeddable but property expects int.',
+24,
+],
+]);
+}
+
+}

@@ -0,0 +1,17 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Doctrine\ORM;
+
+use Doctrine\ORM\Mapping as ORM;
+
+/**
+* @ORM\Embeddable()
+*/
+class BrokenEmbeddable
+{
+/**
+* @ORM\Column(type="string", nullable=true)
+* @var string
+*/
+private $one;
+}

@@ -0,0 +1,25 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Doctrine\ORM;
+
+use Doctrine\ORM\Mapping as ORM;
+
+/**
+* @ORM\Entity()
+*/
+class EntityWithBrokenEmbeddable
+{
+
+/**
+* @ORM\Id()
+* @ORM\Column(type="integer")
+* @var int
+*/
+private $id;
+
+/**
+* @ORM\Embedded(class=Embeddable::class)
+* @var int
+*/
+private $embedded;
+}

@@ -0,0 +1,31 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Doctrine\ORM;
+
+use Doctrine\ORM\Mapping as ORM;
+
+/**
+* @ORM\Entity()
+*/
+class EntityWithEmbeddable
+{
+
+/**
+* @ORM\Id()
+* @ORM\Column(type="integer")
+* @var int
+*/
+private $id;
+
+/**
+* @ORM\Embedded(class=Embeddable::class)
+* @var Embeddable
+*/
+private $embedded;
+
+/**
+* @ORM\Embedded(class=Embeddable::class)
+* @var ?Embeddable
+*/
+private $nullable;
+}