symfony
diff --git a/‎src/Symfony/Component/DependencyInjection/Compiler/FactoryReturnTypePass.php
Lines changed: 13 additions & 5 deletions b/‎src/Symfony/Component/DependencyInjection/Compiler/FactoryReturnTypePass.php
Lines changed: 13 additions & 5 deletions
diff --git a/‎src/Symfony/Component/DependencyInjection/Tests/Compiler/FactoryReturnTypePassTest.php
Lines changed: 48 additions & 6 deletions b/‎src/Symfony/Component/DependencyInjection/Tests/Compiler/FactoryReturnTypePassTest.php
Lines changed: 48 additions & 6 deletions
diff --git a/‎src/Symfony/Component/DependencyInjection/Tests/Fixtures/FactoryDummy.php
Lines changed: 15 additions & 2 deletions b/‎src/Symfony/Component/DependencyInjection/Tests/Fixtures/FactoryDummy.php
Lines changed: 15 additions & 2 deletions
@@ -48,8 +48,7 @@ private function updateDefinition(ContainerBuilder $container, $id, Definition $
         }
 
         if (is_string($factory) && function_exists($factory)) {
-            $reflection = new \ReflectionFunction($factory);
-            $returnType = $reflection->getReturnType();
+            $reflectionFunction = new \ReflectionFunction($factory);
         } else {
             if ($factory[0] instanceof Reference) {
                 $this->updateDefinition(
@@ -64,15 +63,24 @@ private function updateDefinition(ContainerBuilder $container, $id, Definition $
             }
 
             try {
-                $reflectionClass = new \ReflectionMethod($class, $factory[1]);
+                $reflectionFunction = new \ReflectionMethod($class, $factory[1]);
             } catch (\ReflectionException $e) {
                 return;
             }
-            $returnType = $reflectionClass->getReturnType();
         }
 
+        $returnType = $reflectionFunction->getReturnType();
         if (null !== $returnType && !$returnType->isBuiltin()) {
-            $definition->setClass((string) $returnType);
+            $returnType = (string) $returnType;
+            if (isset($class)) {
+                if ('self' === $returnType) {
+                    $returnType = $class;
+                } elseif ('parent' === $returnType) {
+                    $returnType = get_parent_class($class) ?: null;
+                }
+            }
+
+            $definition->setClass($returnType);
         }
     }
 }
@@ -15,6 +15,7 @@
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\Reference;
 use Symfony\Component\DependencyInjection\Tests\Fixtures\FactoryDummy;
+use Symfony\Component\DependencyInjection\Tests\Fixtures\FactoryParent;
 
 /**
  * @author Guilhem N. <egetick@gmail.com>
@@ -26,33 +27,74 @@ public function testProcess()
         $container = new ContainerBuilder();
 
         $factory = $container->register('factory');
-        $factory->setFactory(array(FactoryDummy::class, 'createSelf'));
+        $factory->setFactory(array(FactoryDummy::class, 'createFactory'));
 
         $foo = $container->register('foo');
         $foo->setFactory(array(new Reference('factory'), 'create'));
 
+        $bar = $container->register('bar', __CLASS__);
+        $bar->setFactory(array(new Reference('factory'), 'create'));
+
         $pass = new FactoryReturnTypePass();
         $pass->process($container);
 
-        if (PHP_VERSION_ID >= 70000) {
+        if (method_exists(\ReflectionMethod::class, 'getReturnType')) {
             $this->assertEquals(FactoryDummy::class, $factory->getClass());
             $this->assertEquals(\stdClass::class, $foo->getClass());
         } else {
             $this->assertNull($factory->getClass());
             $this->assertNull($foo->getClass());
         }
+        $this->assertEquals(__CLASS__, $bar->getClass());
     }
 
-    public function testBuiltinReturnType()
+    /**
+     * @dataProvider returnTypesProvider
+     */
+    public function testReturnTypes($method, $returnType, $hhvmSupport = true)
     {
+        if (!$hhvmSupport && defined('HHVM_VERSION')) {
+            $this->markTestSkipped('Special types not supported by hhvm.');
+        }
+
         $container = new ContainerBuilder();
 
-        $service = $container->register('builtin');
-        $service->setFactory(array(FactoryDummy::class, 'createBuiltin'));
+        $service = $container->register('service');
+        $service->setFactory(array(FactoryDummy::class, $method));
+
+        $pass = new FactoryReturnTypePass();
+        $pass->process($container);
+
+        if (method_exists(\ReflectionMethod::class, 'getReturnType')) {
+            $this->assertEquals($returnType, $service->getClass());
+        } else {
+            $this->assertNull($service->getClass());
+        }
+    }
+
+    public function returnTypesProvider()
+    {
+        return array(
+            array('createBuiltin', null, false),
+            array('createParent', FactoryParent::class),
+            array('createSelf', FactoryDummy::class),
+        );
+    }
+
+    {
+        $container = new ContainerBuilder();
+
+        $factory = $container->register('factory');
+        $factory->setFactory(array(new Reference('factory2'), 'createSelf'));
+
+        $factory2 = $container->register('factory2');
+        $factory2->setFactory(array(new Reference('factory'), 'create'));
 
         $pass = new FactoryReturnTypePass();
         $pass->process($container);
 
-        $this->assertNull($service->getClass());
+        $this->assertNull($factory->getClass());
+        $this->assertNull($factory2->getClass());
     }
 }
@@ -11,17 +11,30 @@
 
 namespace Symfony\Component\DependencyInjection\Tests\Fixtures;
 
-class FactoryDummy
+class FactoryDummy extends FactoryParent
 {
-    public static function createSelf(): FactoryDummy
+    public static function createFactory(): FactoryDummy
     {
     }
 
     public function create(): \stdClass
     {
     }
 
+    // Not supported by hhvm
     public function createBuiltin(): int
     {
     }
+
+    public static function createSelf(): self
+    {
+    }
+
+    public static function createParent(): parent
+    {
+    }
+}
+
+class FactoryParent
+{
 }