diff --git a/phpunit/code/variable-variable-arraydim.php b/phpunit/code/variable-variable-arraydim.php
new file mode 100644
index 00000000..9a5db13f
--- /dev/null
+++ b/phpunit/code/variable-variable-arraydim.php
@@ -0,0 +1,8 @@
+<?php
+
+function variable_variable_with_array_dim(): void
+{
+    $foo = ['bar' => 'hello'];
+    ${$foo['bar']} = 'world';
+    echo $hello;
+}
diff --git a/phpunit/code/variable-variable-function-call.php b/phpunit/code/variable-variable-function-call.php
new file mode 100644
index 00000000..26fd0ef1
--- /dev/null
+++ b/phpunit/code/variable-variable-function-call.php
@@ -0,0 +1,12 @@
+<?php
+
+function variable_name(): string
+{
+    return 'hello';
+}
+
+function variable_variable_with_function_call(): void
+{
+    ${variable_name()} = 'world';
+    echo $hello;
+}
diff --git a/phpunit/src/VariableVariableTest.php b/phpunit/src/VariableVariableTest.php
new file mode 100644
index 00000000..8afce89b
--- /dev/null
+++ b/phpunit/src/VariableVariableTest.php
@@ -0,0 +1,14 @@
+<?php
+
+class VariableVariableTest extends \BaseTest
+{
+    public function testVariableVariableWithArrayDimThrowsUnsupportedError(): void
+    {
+        $this->exec('The `$$` syntax is not supported', 'variable-variable-arraydim.php');
+    }
+
+    public function testVariableVariableWithFunctionCallThrowsUnsupportedError(): void
+    {
+        $this->exec('The `$$` syntax is not supported', 'variable-variable-function-call.php');
+    }
+}
diff --git a/src/CompilerBase.php b/src/CompilerBase.php
index 074a1517..e5355646 100644
--- a/src/CompilerBase.php
+++ b/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);
@@ -1066,6 +1072,21 @@ class CompilerBase implements PropertyAccessContext
         return $this->wrapVoidExprAsNull($expr, $this->parseExpr($expr));
     }
 
+    /**
+     * Snapshot a reference-returning call before a by-value container can retain
+     * its php::Ref. Assigning to an existing Var detaches the reference, unlike
+     * constructing a Variant directly from Ref. Keep the assignment inline so
+     * earlier arguments or array elements retain PHP's evaluation order.
+     */
+    protected function materializeRefReturnAsValue(NodeAbstract $value, string $expr): string
+    {
+        if ($value instanceof Expr\CallLike && $this->resolveRefReturningCall($value) !== false) {
+            $tmpVar = $this->addTmpVar(Type::VAR);
+            return '(' . $tmpVar . ' = ' . $expr . ')';
+        }
+        return $expr;
+    }
+
     protected function getObjectPropVarName(string $object, string $prop): string
     {
         return self::OBJECT_PROP . $object . self::NAMESPACE_SEPARATOR . $prop;
@@ -1273,7 +1294,7 @@ class CompilerBase implements PropertyAccessContext
 
     protected function parseVariable(Variable $expr): string
     {
-        if (is_object($expr->name) and $this->isVarExpr($expr->name)) {
+        if (!is_string($expr->name)) {
             $this->fatalError($expr, 'The `$$` syntax is not supported');
         }
         if ($this->isSuperGlobal($expr->name)) {
diff --git a/src/Generator/CallArgumentGenerator.php b/src/Generator/CallArgumentGenerator.php
index 0347667e..79431f24 100644
--- a/src/Generator/CallArgumentGenerator.php
+++ b/src/Generator/CallArgumentGenerator.php
@@ -586,6 +586,13 @@ trait CallArgumentGenerator
 
     protected function materializeCallArgValue(NodeAbstract $value, string $expr): string
     {
+        // A call that returns by reference yields a live php::Ref aliasing the
+        // callee's storage. When such a call feeds a by-value argument, PHP takes
+        // a value snapshot at evaluation time (left to right), so later mutations
+        // to the aliased storage must not be observable. The dynamic ArgList keeps
+        // references verbatim (Ctor::CopyRef), so we dereference into a temporary
+        // value at the point of the call.
+        $expr = $this->materializeRefReturnAsValue($value, $expr);
         if (!$this->shouldMaterializeCallArg($value)) {
             return $expr;
         }
diff --git a/src/Generator/TypeCheckGenerator.php b/src/Generator/TypeCheckGenerator.php
index 16dc4ae3..292967a1 100644
--- a/src/Generator/TypeCheckGenerator.php
+++ b/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') {
diff --git a/src/Parser/ArrayExpressionTrait.php b/src/Parser/ArrayExpressionTrait.php
index a920f62b..819cf8cf 100644
--- a/src/Parser/ArrayExpressionTrait.php
+++ b/src/Parser/ArrayExpressionTrait.php
@@ -60,7 +60,7 @@ trait ArrayExpressionTrait
         $this->indentLevel++;
         foreach ($items as $item) {
             $this->assertExprCanBeUsedAsValue($item->value, 'array value');
-            $value = $this->parseIdentifier($item->value);
+            $value = $this->materializeRefReturnAsValue($item->value, $this->parseIdentifier($item->value));
             if ($item->key) {
                 $this->assertExprCanBeUsedAsValue($item->key, 'array key');
                 $key = $this->parseArrayKey($item->key);
@@ -221,7 +221,7 @@ trait ArrayExpressionTrait
                 }
                 $value = $this->convertToRef($item->value);
             } else {
-                $value = $this->parseIdentifier($item->value);
+                $value = $this->materializeRefReturnAsValue($item->value, $this->parseIdentifier($item->value));
             }
             if ($item->unpack) {
                 $this->context->beforeStmtLines[] = $this->getIndent() . $tmpVar . '.merge(' . $value . ');';
diff --git a/src/Parser/AssignOpTrait.php b/src/Parser/AssignOpTrait.php
index cf826761..dabef684 100644
--- a/src/Parser/AssignOpTrait.php
+++ b/src/Parser/AssignOpTrait.php
@@ -862,9 +862,17 @@ trait AssignOpTrait
     protected function parseAssignOpCoalesce(Expr\AssignOp\Coalesce $expr): string
     {
         $this->checkLeftValue($expr->var);
+
+        // An undefined variable must exist before generating its isset check.
+        // Keep it as Variant so NULL remains distinguishable from native defaults.
+        $var = $this->isVarExpr($expr->var) ? $this->parseIdentifier($expr->var) : null;
+        if ($var !== null && !$this->hasVar($var)) {
+            $this->addLocalVar($var, Type::VAR);
+        }
+
         $isset = $this->parseChainedExpr($expr->var, self::OP_ISSET);
 
-        $var = $this->parseWritableIdentifier($expr->var);
+        $var ??= $this->parseWritableIdentifier($expr->var);
         $propertyWriteTarget = $this->preparePropertyWriteTarget($expr->var);
 
         if ($propertyWriteTarget !== null) {
@@ -878,9 +886,6 @@ trait AssignOpTrait
         if ($this->isVarExpr($expr->expr) and !$this->hasVar($right)) {
             $this->errorUndefinedVariable($expr->expr);
         }
-        if ($this->isVarExpr($expr->var) and !$this->hasVar($var)) {
-            $this->addLocalVar($var, $this->getNormalAssignType($this->detectTypeOfExpr($expr->expr)));
-        }
         return '(' . $isset . '?' . $var . ':(' . $var . ' = ' . $right . '))';
     }
 
diff --git a/src/Resolver/NameResolutionTrait.php b/src/Resolver/NameResolutionTrait.php
index 307117e5..827db4a3 100644
--- a/src/Resolver/NameResolutionTrait.php
+++ b/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');
diff --git a/src/Translator.php b/src/Translator.php
index 70d063a9..aa6e2eb7 100644
--- a/src/Translator.php
+++ b/src/Translator.php
@@ -3242,6 +3242,7 @@ CODE;
             return $arg->typeCheck;
         }
 
+        $declaredClass = $arg->declaredClass ?: $arg->class;
         return match ($arg->type) {
             Type::INT => [['kind' => 'isInt']],
             Type::FLOAT => [['kind' => 'isFloat']],
@@ -3249,8 +3250,8 @@ CODE;
             Type::STR => [['kind' => 'isString']],
             Type::ARRAY => [['kind' => 'isArray']],
             Type::RESOURCE => [['kind' => 'isResource']],
-            Type::OBJECT => $arg->class
-                ? [['kind' => 'instanceof', 'class' => $arg->class]]
+            Type::OBJECT => $declaredClass
+                ? [['kind' => 'instanceof', 'class' => $declaredClass]]
                 : [['kind' => 'isObject']],
             default => null,
         };
diff --git a/tests/compiler/class/interface-method-self-return.phpt b/tests/compiler/class/interface-method-self-return.phpt
new file mode 100644
index 00000000..90e44eab
--- /dev/null
+++ b/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)
diff --git a/tests/compiler/coalesce/assign-coalesce-undefined-var.phpt b/tests/compiler/coalesce/assign-coalesce-undefined-var.phpt
new file mode 100644
index 00000000..27dd886b
--- /dev/null
+++ b/tests/compiler/coalesce/assign-coalesce-undefined-var.phpt
@@ -0,0 +1,28 @@
+--TEST--
+assign coalesce on undefined variable
+--FILE--
+<?php
+$a ??= 123;
+var_dump($a);
+
+$b ??= 'foo';
+$b ??= 'bar';
+var_dump($b);
+
+$c ??= null;
+var_dump(isset($c));
+$c ??= 'after-null';
+var_dump($c);
+
+for ($i = 0; $i < 2; $i++) {
+    $d ??= printf("default\n");
+}
+var_dump($d);
+?>
+--EXPECT--
+int(123)
+string(3) "foo"
+bool(false)
+string(10) "after-null"
+default
+int(8)
diff --git a/tests/compiler/namespace/interface-impl-param-type-cross-ns.phpt b/tests/compiler/namespace/interface-impl-param-type-cross-ns.phpt
new file mode 100644
index 00000000..535212a7
--- /dev/null
+++ b/tests/compiler/namespace/interface-impl-param-type-cross-ns.phpt
@@ -0,0 +1,62 @@
+--TEST--
+Cross-namespace interface implementation parameter compatibility is declaration-order independent
+--FILE--
+<?php
+namespace A {
+    use B\I0;
+    use B\I1;
+    use B\I2;
+
+    abstract class Test implements I2
+    {
+        public function test(I1 $a): bool
+        {
+            return true;
+        }
+
+        public function testParent(I0 $a): bool
+        {
+            return true;
+        }
+    }
+}
+
+namespace B {
+    interface I0
+    {
+    }
+
+    interface I1 extends I0
+    {
+    }
+
+    interface I2
+    {
+        public function test(I1 $a): bool;
+
+        public function testParent(I1 $a): bool;
+    }
+
+    class Impl1 implements I1
+    {
+    }
+}
+
+namespace {
+    class Concrete extends \A\Test
+    {
+    }
+
+    function main()
+    {
+        $obj = new Concrete();
+        var_dump($obj->test(new \B\Impl1()));
+        var_dump($obj->testParent(new \B\Impl1()));
+        echo "done\n";
+    }
+}
+?>
+--EXPECT--
+bool(true)
+bool(true)
+done
diff --git a/tests/compiler/namespace/interface-self-return-namespaced.phpt b/tests/compiler/namespace/interface-self-return-namespaced.phpt
new file mode 100644
index 00000000..4d05a98a
--- /dev/null
+++ b/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)
diff --git a/tests/compiler/ref/dynamic-return-reference-argument.phpt b/tests/compiler/ref/dynamic-return-reference-argument.phpt
new file mode 100644
index 00000000..aede4d2a
--- /dev/null
+++ b/tests/compiler/ref/dynamic-return-reference-argument.phpt
@@ -0,0 +1,80 @@
+--TEST--
+Reference-returning calls are copied by value when used as call arguments or array elements
+--FILE--
+<?php
+
+function main()
+{
+    $v1 = &test1();
+    var_dump($v1);
+    $v2 = &test1();
+    var_dump($v2);
+    var_dump($v1, $v2);
+    $v1 = 0;
+    var_dump($v1, $v2);
+    var_dump(test1(), test2());
+    var_dump([test1(), test2()]);
+    var_dump(['first' => test1(), test2()]);
+    var_dump(value_order('arg-left'), ref_order('arg-ref'));
+    var_dump([value_order('array-left'), ref_order('array-ref')]);
+}
+
+function &test1()
+{
+    $callback = 'test2';
+    return $callback();
+}
+
+function &test2()
+{
+    static $value = 0;
+    ++$value;
+    return $value;
+}
+
+function value_order(string $label): string
+{
+    echo "$label\n";
+    return $label;
+}
+
+function &ref_order(string $label)
+{
+    static $value = 42;
+    echo "$label\n";
+    return $value;
+}
+?>
+--EXPECT--
+int(1)
+int(2)
+int(2)
+int(2)
+int(0)
+int(0)
+int(1)
+int(2)
+array(2) {
+  [0]=>
+  int(3)
+  [1]=>
+  int(4)
+}
+array(2) {
+  ["first"]=>
+  int(5)
+  [0]=>
+  int(6)
+}
+arg-left
+arg-ref
+string(8) "arg-left"
+int(42)
+array-left
+array-ref
+array(2) {
+  [0]=>
+  string(10) "array-left"
+  [1]=>
+  int(42)
+}