Declared typed variable can be reassigned through closure use-by-reference

[jefyokta]

Description

TypePHP does not report an error when a declared variable is passed by reference into a closure and then assigned a value of a different type.

Reproduction

<?php

function main()
{
 $num = 1;
 $str = "str";

 (static function () use (&$num) {
 $num = [];
 })();

 (static function () use (&$str) {
 $str = [];
 })();

 var_dump($num, $str);
}

Expected behavior

TypePHP should detect that $num and $str are inferred as incompatible types and report a type error when they are assigned an array through the referenced closure variable.

For example:

Cannot assign array to variable $num of type int
Cannot assign array to variable $str of type string

Actual behavior

TypePHP compiles the code without any error.

The closure receives $num and $str by reference:

use (&$num)
use (&$str)

and mutates their types inside the closure:

$num = [];
$str = [];

The type mutation is currently not detected.

Question outside the issue

Btw, are you focusing on refactoring right now?

I made some commits for my previous issue, but they require phpx's current dev-master version, so I haven't submitted the PR yet.

I noticed that your recent commits seem to be mostly focused on refactoring. What is the current focus of the project?

I've opened quite a few issues about type checking and other type-related features because I thought TypePHP was mainly focused on bringing stronger typing to PHP. But I understand that the project was renamed from PHP AOT to TypePHP, so the rename itself might not mean that the project's direction changed.

That said, it still seems like the project is mainly focused on the AOT compiler, while the type-related features are still fairly limited. What is the project's current focus and overall direction? I just want to make sure I'm contributing and opening issues in the right areas.

[matyhtf]

The implementation of zendvm reference is typeless, which means it cannot constrain the type of zend_reference. This is a defect in the implementation of zendvm. TypePHP still requires the use of zend_reference to implement references for compatibility.

Therefore, modifying the type of a variable after referencing will be an undefined behavior in typephp, which the compiler cannot detect and there are no type constraints at runtime. This may even lead to a crash. Therefore, developers need to ensure on their own.

[matyhtf]

Before version 1.0, the underlying layer may be refactored at any time, and some features are not stable and may change. Suggest submitting only issues, feature requests, or other ideas.
During our refactoring phase, we will reject all PRs. However, in the stable version phase, some bug fixes can be merged first.

[matyhtf]

Your understanding is correct—beyond its AOT compiler, the most significant difference between TypePHP and ZendPHP in language design is that TypePHP is engineered as a statically and strongly typed language, meaning a variable's type is fixed upon declaration and cannot be altered. The issue with Int arises because, currently, to maintain compatibility with ZendPHP, operations that overflow automatically convert to floating-point, or divisions that do not result in an exact quotient also convert to floating-point. Thus, prior to TypePHP version 0.7, $var = 100; would declare $var as the php::Var type rather than php::Int, allowing it to be reassigned to a string or an array. Starting from version 0.8, we removed this behavior, now declaring it as php::Int and prohibiting type changes. However, this simultaneously sacrifices compatibility with PHP—for instance, $var += PHP_INT_MAX will no longer convert to a floating-point number, and $var = 10; $var /= 3; will yield 3 rather than 3.3333...

[matyhtf]

This has been resolved by the strongly typed reference refactoring for TypePHP 0.8.

Fixed scalar and array storage now has explicit typed-reference semantics. Direct native calls can use these typed references safely, while a Closure is a runtime ZendVM object and cannot preserve the same statically typed reference contract. Therefore, capturing a fixed variable such as php::Int or php::Str by reference in a Closure is now rejected at compile time.

If dynamic Zend reference semantics are intentionally required, initialize the value with std::any() so it uses php::Var storage. Assignments through that reference then follow the dynamic ZendVM path.

The previous statement that this would remain undefined behavior is no longer applicable after the 0.8 refactoring. The original reproduction now fails safely during TypePHP compilation, so this issue is fixed.