fix: 27 correctness divergences from Zend 8.4 across codegen, folding, and declaration validation

phpunit/bootstrap.php

@@ -5,6 +5,21 @@
 use TypePhp\Exception\TestError;
 
 require __DIR__ . '/../bin/bootstrap.php';
+
+// The vendor directory may be shared between checkouts (e.g. a git worktree
+// with a symlinked vendor/). Composer's autoloader resolves TypePhp\ against
+// the checkout that owns vendor/, which would silently test another tree's
+// sources. Prepend a loader anchored to THIS checkout so the test suite always
+// exercises the code it ships with.
+spl_autoload_register(static function (string $class): void {
+    if (str_starts_with($class, 'TypePhp\\')) {
+        $path = dirname(__DIR__) . '/src/' . str_replace('\\', '/', substr($class, strlen('TypePhp\\'))) . '.php';
+        if (is_file($path)) {
+            require $path;
+        }
+    }
+}, true, true);
+
 require_once __DIR__ . '/../src/polyfills.php';
 require __DIR__ . '/../src/gen_stub.php';
 

phpunit/code/abstract_redeclare_concrete.php

@@ -0,0 +1,5 @@
+<?php
+class A { public function f(): int { return 1; } }
+abstract class B extends A { abstract public function f(): int; }
+
+function main() {}

phpunit/code/abstract_redeclare_incompatible.php

@@ -0,0 +1,5 @@
+<?php
+abstract class A { abstract public function f(): int; }
+abstract class B extends A { abstract public function f(): string; }
+
+function main() {}

phpunit/code/abstract_redeclare_internal.php

@@ -0,0 +1,4 @@
+<?php
+abstract class B extends ArrayObject { abstract public function count(): int; }
+
+function main() {}

phpunit/code/abstract_redeclare_valid.php

@@ -0,0 +1,15 @@
+<?php
+// Redeclaring an inherited abstract contract compatibly is legal, a parent's
+// private method is not inherited, and a trait's abstract requirement may be
+// satisfied by an inherited concrete method.
+abstract class A { abstract public function f(): int; }
+abstract class B extends A { abstract public function f(): int; }
+
+class C { private function g(): int { return 1; } }
+abstract class D extends C { abstract public function g(): int; }
+
+trait RequiresF { abstract public function h(): int; }
+class E { public function h(): int { return 1; } }
+class F extends E { use RequiresF; }
+
+function main() {}

phpunit/code/abstract_rule_body.php

@@ -0,0 +1,4 @@
+<?php
+abstract class Job { abstract public function run(): void {} }
+
+function main() {}

phpunit/code/abstract_rule_private.php

@@ -0,0 +1,4 @@
+<?php
+abstract class Job { abstract private function run(): void; }
+
+function main() {}

phpunit/code/abstract_rule_private_trait_valid.php

@@ -0,0 +1,19 @@
+<?php
+trait JobTrait
+{
+    abstract private function run(): void;
+
+    public function go(): void
+    {
+        $this->run();
+    }
+}
+
+class Job
+{
+    use JobTrait;
+
+    private function run(): void {}
+}
+
+function main() {}

phpunit/code/coalesce-assign-side-effect-codegen.php

@@ -0,0 +1,21 @@
+<?php
+
+function sideEffectCall(): int
+{
+    echo "side effect!\n";
+    return 41;
+}
+
+function coalesceCompoundRhs(): int
+{
+    $target = 1;
+    $target ??= sideEffectCall() + 1;
+    return $target;
+}
+
+function coalesceSimpleRhs(): int
+{
+    $target = 1;
+    $target ??= sideEffectCall();
+    return $target;
+}

phpunit/code/const_override_covariant.php

@@ -0,0 +1,17 @@
+<?php
+class A
+{
+    const int|string X = 1;
+    const mixed M = 1;
+    const ?int N = null;
+}
+
+class B extends A
+{
+    // PHP 8.3 typed constants are covariant: narrowing is allowed.
+    const int X = 2;
+    const string M = 'a';
+    const int N = 5;
+}
+
+function main() {}

phpunit/code/const_override_unrelated.php

@@ -0,0 +1,12 @@
+<?php
+class A
+{
+    const int X = 1;
+}
+
+class B extends A
+{
+    const string X = 'a';
+}
+
+function main() {}

phpunit/code/const_override_widened.php

@@ -0,0 +1,12 @@
+<?php
+class A
+{
+    const int X = 1;
+}
+
+class B extends A
+{
+    const int|string X = 2;
+}
+
+function main() {}

phpunit/code/const_rule_callable.php

@@ -0,0 +1,4 @@
+<?php
+class Bag { const callable FN = 1; }
+
+function main() {}

phpunit/code/ctor_override_abstract_incompatible.php

@@ -0,0 +1,12 @@
+<?php
+abstract class A
+{
+    abstract public function __construct(int $x);
+}
+
+class B extends A
+{
+    public function __construct(string $x) {}
+}
+
+function main() {}

phpunit/code/ctor_override_final.php

@@ -0,0 +1,12 @@
+<?php
+class A
+{
+    final public function __construct() {}
+}
+
+class B extends A
+{
+    public function __construct() {}
+}
+
+function main() {}

phpunit/code/ctor_override_final_private.php

@@ -0,0 +1,12 @@
+<?php
+class A
+{
+    final private function __construct() {}
+}
+
+class B extends A
+{
+    public function __construct() {}
+}
+
+function main() {}

phpunit/code/ctor_override_valid.php

@@ -0,0 +1,39 @@
+<?php
+class A
+{
+    public function __construct(int $x) {}
+}
+
+// A concrete parent constructor imposes no signature contract: the child may
+// change the parameters and even narrow visibility.
+class B extends A
+{
+    private function __construct(string $y, array $z)
+    {
+        parent::__construct(1);
+    }
+}
+
+class C
+{
+    private function __construct(int $x) {}
+}
+
+// A private parent constructor may be redeclared freely.
+class D extends C
+{
+    public function __construct(string $y) {}
+}
+
+abstract class E
+{
+    abstract public function __construct(int $x);
+}
+
+// Adding optional trailing parameters satisfies an abstract constructor.
+class F extends E
+{
+    public function __construct(int $x, string $y = '') {}
+}
+
+function main() {}

phpunit/code/decimal-literal-classification.php

@@ -0,0 +1,31 @@
+<?php
+
+function fifteenSigDigitsWithExponent(): bool
+{
+    return is_float(1.23456789012345e300);
+}
+
+function trailingZerosAreNotSignificant(): bool
+{
+    return is_float(999999999999999.0);
+}
+
+function roundTripSixteenDigits(): bool
+{
+    return is_float(2.220446049250313E-16);
+}
+
+function hexLiteralStaysNumeric(): float
+{
+    return 0x123456789E1234567;
+}
+
+function autoDecimalKeepsPromotion()
+{
+    return 3.14159265358979323846;
+}
+
+function decimalLiteralDemotesAgainstFloat(float $f): bool
+{
+    return $f == 3.14159265358979323846;
+}

phpunit/code/enum-case-class-constant.php

@@ -0,0 +1,23 @@
+<?php
+
+enum CaseConstEnum: int
+{
+    case A = 1 + 1;
+    case B = 4;
+}
+
+interface CaseConstInterface
+{
+    const IC = CaseConstEnum::B;
+}
+
+class CaseConstHolder implements CaseConstInterface
+{
+    const CB = CaseConstEnum::B;
+    const CHAIN = self::CB;
+}
+
+function main(): void
+{
+    var_dump(CaseConstHolder::CB === CaseConstEnum::B);
+}

phpunit/code/enum_interface_const_final.php

@@ -0,0 +1,13 @@
+<?php
+interface I
+{
+    final const X = 1;
+}
+
+enum E implements I
+{
+    const X = 2;
+    case A;
+}
+
+function main() {}

phpunit/code/enum_rule_abstract_method.php

@@ -0,0 +1,4 @@
+<?php
+enum Suit { case Hearts; abstract public function f(): void; }
+
+function main() {}

phpunit/code/enum_rule_backing_type.php

@@ -0,0 +1,4 @@
+<?php
+enum Suit: float { case Hearts = 1.0; }
+
+function main() {}

phpunit/code/enum_rule_case_const_clash.php

@@ -0,0 +1,4 @@
+<?php
+enum Suit { const Hearts = 1; case Hearts; }
+
+function main() {}

phpunit/code/enum_rule_case_missing_value.php

@@ -0,0 +1,4 @@
+<?php
+enum Suit: int { case Hearts; }
+
+function main() {}

phpunit/code/enum_rule_case_value_nonbacked.php

@@ -0,0 +1,4 @@
+<?php
+enum Suit { case Hearts = 1; }
+
+function main() {}

phpunit/code/enum_rule_duplicate_case.php

@@ -0,0 +1,4 @@
+<?php
+enum Suit { case Hearts; case Hearts; }
+
+function main() {}

phpunit/code/enum_rule_extends_enum.php

@@ -0,0 +1,5 @@
+<?php
+enum Suit { case Hearts; }
+class Deck extends Suit {}
+
+function main() {}

phpunit/code/enum_rule_implements_backedenum_nonbacked.php

@@ -0,0 +1,4 @@
+<?php
+enum Suit implements BackedEnum { case Hearts; }
+
+function main() {}

phpunit/code/enum_rule_implements_unitenum.php

@@ -0,0 +1,4 @@
+<?php
+enum Suit implements UnitEnum { case Hearts; }
+
+function main() {}

phpunit/code/enum_rule_magic_construct.php

@@ -0,0 +1,4 @@
+<?php
+enum Suit { case Hearts; public function __construct() {} }
+
+function main() {}

phpunit/code/enum_rule_magic_tostring.php

@@ -0,0 +1,4 @@
+<?php
+enum Suit { case Hearts; public function __toString(): string { return ""; } }
+
+function main() {}

phpunit/code/enum_rule_property.php

@@ -0,0 +1,4 @@
+<?php
+enum Suit { case Hearts; public int $x = 1; }
+
+function main() {}

phpunit/code/enum_rule_static_property.php

@@ -0,0 +1,4 @@
+<?php
+enum Suit { case Hearts; public static int $x = 1; }
+
+function main() {}

phpunit/code/enum_rule_valid.php

@@ -0,0 +1,4 @@
+<?php
+enum Suit: string { const Wild = "w"; case Hearts = "h"; case Spades = "s"; public function label(): string { return $this->value; } public function __invoke(): string { return $this->label(); } }
+
+function main() {}