fix(optimizer): round() must not lower a RoundingMode enum to an int

Since PHP 8.4 the third parameter of round() is a RoundingMode enum, but
php::fn::round() models the mode as an Int, which only covers the legacy
PHP_ROUND_* constants. genRound sent the argument through convertIntExpr
regardless, so the enum went through an object-to-int conversion that
yields 1 - PHP_ROUND_HALF_UP:

    round(2.5, 0, RoundingMode::HalfEven);
    // compiled: Warning: Object of class RoundingMode could not be
    //           converted to int
    // compiled: 3
    // PHP:      2

Banker's rounding silently became half away from zero. Code that spells
out HalfEven is usually money code, where that is the exact difference it
was avoiding.

A mode that is not statically an int now falls through to the dynamic
path, which passes the enum to the runtime function unchanged. The legacy
integer constants keep the native call - PHP_ROUND_HALF_DOWN still lowers
to a plain 2L - and the one and two argument forms are untouched.

Only the compile-time lowering is covered by a test here. A runtime PHPT
cannot pass yet: phpx resolves a class constant on an internal class by
reading the raw zval out of the constants table, so RoundingMode::HalfEven
does not materialise at all. That is reported separately; once it ships,
the runtime case can be added to type_conv-style coverage.

Author: Giandonn

hello

@@ -0,0 +1,12 @@
+<?php
+/**
+ * This file is part of TypePHP(AOT).
+ *
+ * @link     https://www.swoole.com/aot/
+ * @contact  service@swoole.com
+ */
+
+function main(): void
+{
+    var_dump(round(2.5, 0, PHP_ROUND_HALF_DOWN));
+}

phpunit/code/round-with-legacy-mode.php

@@ -0,0 +1,12 @@
+<?php
+/**
+ * This file is part of TypePHP(AOT).
+ *
+ * @link     https://www.swoole.com/aot/
+ * @contact  service@swoole.com
+ */
+
+function main(): void
+{
+    var_dump(round(2.5, 0, RoundingMode::HalfEven));
+}

phpunit/code/round-with-mode.php

@@ -0,0 +1,51 @@
+<?php
+/**
+ * This file is part of TypePHP(AOT).
+ *
+ * @link     https://www.swoole.com/aot/
+ * @contact  service@swoole.com
+ */
+
+namespace TypePhp\Tests;
+
+use PHPUnit\Framework\TestCase;
+use TypePhp\CompilerTest;
+
+/**
+ * @internal
+ * @coversNothing
+ */
+class RoundModeTest extends TestCase
+{
+    public function testRoundingModeReachesTheRuntimeUnconverted(): void
+    {
+        global $translator;
+
+        $compiler = CompilerTest::create(TYPEPHP_ROOT_PATH);
+        $translator = $compiler;
+        $source = TYPEPHP_ROOT_PATH . '/phpunit/code/round-with-mode.php';
+        $compiler->addFiles([$source]);
+        $compiler->prepareFile($source);
+        $cpp = file_get_contents($compiler->convertFile($source));
+
+        // php::fn::round() models the mode as an Int, so an enum must not be
+        // lowered to it: the conversion turns HalfEven into half away from
+        // zero. The call goes to the runtime with the enum intact instead.
+        self::assertStringNotContainsString('php::fn::round(', $cpp);
+        self::assertStringContainsString('php::constant(', $cpp);
+    }
+
+    public function testLegacyIntegerModeKeepsTheNativeCall(): void
+    {
+        global $translator;
+
+        $compiler = CompilerTest::create(TYPEPHP_ROOT_PATH);
+        $translator = $compiler;
+        $source = TYPEPHP_ROOT_PATH . '/phpunit/code/round-with-legacy-mode.php';
+        $compiler->addFiles([$source]);
+        $compiler->prepareFile($source);
+        $cpp = file_get_contents($compiler->convertFile($source));
+
+        self::assertStringContainsString('php::fn::round(', $cpp);
+    }
+}

phpunit/src/RoundModeTest.php

@@ -792,7 +792,7 @@ protected function genArrayKeyExists(string $n, Node\Expr\FuncCall $e, array $c)
         return $array . '.offsetExists(' . $key . ')';
     }
 
-    protected function genRound(string $n, Node\Expr\FuncCall $e, array $c): string
+    protected function genRound(string $n, Node\Expr\FuncCall $e, array $c): string|false
     {
         $type = $this->detectTypeOfExpr($e->args[0]->value);
         if ($type === Type::DECIMAL) {
@@ -804,6 +804,13 @@ protected function genRound(string $n, Node\Expr\FuncCall $e, array $c): string
         }
         $args = count($e->args);
         if ($args >= 3) {
+            // php::fn::round() models the mode as an Int, which covers only the
+            // legacy PHP_ROUND_* constants. Since PHP 8.4 the parameter is a
+            // RoundingMode enum: converting it to an int picks a different mode,
+            // so anything that is not statically an int goes to the runtime.
+            if ($this->detectTypeOfExpr($e->args[2]->value) !== Type::INT) {
+                return false;
+            }
             return 'php::fn::round(' . $this->getArg($e, 0) . ', ' . $this->convertIntExpr($this->getArg($e, 1)) . ', ' . $this->convertIntExpr($this->getArg($e, 2)) . ')';
         }
         if ($args >= 2) {