src/CompilerBase.php

@@ -1020,6 +1020,12 @@ class CompilerBase implements PropertyAccessContext
         return ltrim($this->namespace . '\\' . $this->class, '\\');
     }
 
+    protected function getFullClassLikeName(): string
+    {
+        $name = $this->class !== '' ? $this->class : $this->interface;
+        return ltrim($this->namespace . '\\' . $name, '\\');
+    }
+
     protected function getFullMethodName(string $fullClassName, string $method): string
     {
         return strtolower($fullClassName . '::' . $method);

src/Generator/TypeCheckGenerator.php

@@ -104,7 +104,7 @@ trait TypeCheckGenerator
         }
 
         if ($name === 'self') {
-            $class = $this->getFullClassName();
+            $class = $this->getFullClassLikeName();
         } elseif ($name === 'parent') {
             $class = $this->classDef->extends ?? '';
         } elseif ($name === 'static') {

src/Resolver/NameResolutionTrait.php

@@ -166,7 +166,7 @@ trait NameResolutionTrait
                 return $this->getTypeFromZendType($typeNameLower);
             } else {
                 if ($typeName === 'self') {
-                    $class = $this->getFullClassName();
+                    $class = $this->getFullClassLikeName();
                 } elseif ($typeName === 'parent') {
                     if (!$this->classDef) {
                         $this->fatalError($type, 'Cannot use "parent" type declaration outside a class');

tests/compiler/class/interface-method-self-return.phpt

@@ -0,0 +1,42 @@
+--TEST--
+interface method with `self` return type implemented by class (fluent interface), and namespace block containing comments
+--FILE--
+<?php
+
+namespace {
+    interface TestInterface
+    {
+        public function get(): self;
+    }
+
+    class TestClass implements TestInterface
+    {
+        public int $value = 0;
+
+        public function get(): self
+        {
+            return $this;
+        }
+
+        public function setValue(int $value): self
+        {
+            $this->value = $value;
+            return $this;
+        }
+    }
+
+    function main()
+    {
+        $test = new TestClass;
+        // get() returns self, so the result still satisfies the interface
+        var_dump($test->get() instanceof TestInterface);
+        var_dump($test === $test->get());
+        // fluent chaining of self-returning methods
+        var_dump($test->get()->setValue(42)->value);
+    }
+}
+?>
+--EXPECT--
+bool(true)
+bool(true)
+int(42)

tests/compiler/namespace/interface-self-return-namespaced.phpt

@@ -0,0 +1,56 @@
+--TEST--
+interface method `self` return type resolves to the interface's fully-qualified name inside a named namespace
+--FILE--
+<?php
+
+namespace App {
+    interface Chainable
+    {
+        public function chain(): self;
+
+        public function maybe(bool $present): ?self;
+
+        public function combine(self $other): self;
+    }
+
+    // comment inside a named namespace block (Stmt_Nop)
+    class Widget implements Chainable
+    {
+        public array $log = [];
+
+        public function chain(): self
+        {
+            $this->log[] = 'chain';
+            return $this;
+        }
+
+        public function maybe(bool $present): ?self
+        {
+            return $present ? $this : null;
+        }
+
+        public function combine(Chainable $other): self
+        {
+            return $this;
+        }
+    }
+}
+
+namespace {
+    function main()
+    {
+        $w = new \App\Widget();
+        var_dump($w->chain()->chain() instanceof \App\Chainable);
+        var_dump(count($w->log));
+        var_dump($w->maybe(true) instanceof \App\Chainable);
+        var_dump($w->maybe(false));
+        var_dump($w->combine(new \App\Widget()) === $w);
+    }
+}
+?>
+--EXPECT--
+bool(true)
+int(2)
+bool(true)
+NULL
+bool(true)