fix(preprocessor): validate compound type declarations and class-scope type keywords

[AlessioGiacobbe]

Compound type declarations were not validated for well-formedness — all of these compiled, each a Zend compile fatal (probed individually): duplicate union members after alias/namespace resolution (int|string|int, Foo|\Foo, iterable expanded so iterable|array names the overlapping component); bool/true/false overlaps (bool|false, true|false → "bool must be used instead"); mixed/void/never inside unions; ?mixed, ?null, ?void, ?never; non-class standard types and duplicates inside intersections; self/static return types outside class scope (closures exempt, as Zend compiles them); duplicate implements entries for classes and enums.

One validation helper runs from a resolveTypeDecl override, so parameters, returns, properties, constants, and closures share the same pass without double-firing. use T, T is deliberately still accepted — Zend silently dedupes trait use (probed).

Part of the split of #39.

[matyhtf]

The focused tests pass (14/14), but three Zend type rules still compile successfully:

1. object absorbs every class type:

class Foo {}
function f(object|Foo $value): void {}

Zend: Type Foo|object contains both object and a class type, which is redundant. Track object versus resolved class members in both member orders.

2. Whole DNF groups cannot be skipped:

interface A {}
interface B {}
function f((A&B)|(B&A) $value): void {}

Zend rejects the second intersection as redundant. It also rejects (A&B)|A because the intersection is more restrictive than A. Canonicalize intersection member sets (order-insensitive) and check exact/restrictive DNF redundancy.

3. Class-scope keywords are only checked for a bare return node. They also occur in parameters and nested union/DNF returns:

function f(self $value): void {}
function g(): self|stdClass {}

Both must fail with Cannot use "self" when no class scope is active; this PR compiles them. Validate self/static recursively for every declaration context. static must additionally remain return-only.

Please add negative tests for these forms. The current comment explicitly saying whole-DNF redundancy is not checked documents a known PHP incompatibility, so this is not ready to merge as the compound-type validator.

[AlessioGiacobbe]

All three rule sets implemented, rebased on current master (~40 fresh Zend 8.4.13 probes drove the exact messages and orderings):

1. object + class-type redundancy — fires in both member orders, with Zend's type rendering (class types in source order, builtins in Zend's canonical order); iterable|object and null|object stay legal as in Zend.
2. Whole-DNF redundancy — intersection member sets canonicalized order-insensitively: equal sets reject (Type `B&A` is redundant with type `A&B` ), and a strict superset rejects as more restrictive in both orders ((A&B)|A, A|(A&B), (A&B)|(A&B&C)); (A&B)|(A&C) stays legal. The stale "not checked" comment is gone.
3. Class-scope keywords everywhere — self/parent validated recursively through nullable/union/intersection/DNF in parameters, returns, properties, and class/interface constants; closures stay exempt (Zend allows self there — verified). Two probe findings worth noting: static in a parameter or property type is a parse error in both Zend and php-parser (it can never reach the compiler), and Zend accepts static in class-constant types — so the only reachable static check is the no-class-scope return case, which was already exact. Documented in the commit body.

17 new fixtures (every negative one executed under real Zend and producing exactly the asserted error), 31/31 focused tests green, full suite and sweep identical to base.

[matyhtf]

Please rebase this branch onto the latest master; #45, #52, #59, #63, and #66 have now been merged.

The handling of self/parent/static inside intersections is not correct for DNF types. validateIntersectionTypeDecl() skips these names on the assumption that buildTypeCheckFromNode() rejects them later, but that rejection only runs when the top-level node is an IntersectionType; a DNF intersection nested inside a UnionType goes through buildTypeCheckClause() and is accepted.

For example, inside a class this branch accepts:

class C {
    public function f((self&Countable)|stdClass $value): void {}
}

Zend rejects it with Type self cannot be part of an intersection type. The same needs coverage for parent in a class that actually has a parent. Note the PHP distinction: a bare self&Countable intersection is accepted, while self inside a DNF intersection is rejected, so this cannot be implemented as an unconditional ban in every intersection.

Please validate this at the compound-type layer with the necessary top-level/DNF context and add both positive bare-intersection and negative DNF tests.

[AlessioGiacobbe]

Rebased onto current master and fixed at the compound layer — with one finding from probing PHP 8.4.13 directly: Zend rejects class-scope keywords in every intersection, bare ones included, so the bare/DNF distinction described in the review does not hold on 8.4:

class C { public function f(self&Countable $v): void {} }
// Fatal error: Type self cannot be part of an intersection type

The shape Zend does accept is the keyword as a plain union member beside a DNF group — (Ia&Ib)|self, (Ia&Ib)|parent, (Ia&Ib)|static all compile. parent/static behave the same way in their intersections, and the scope-precedence messages win where applicable (Cannot use "self" when no class scope is active, Cannot use "parent" when current class scope has no parent).

Implementation follows the probed behavior: validateIntersectionTypeDecl() now rejects self/parent/static unconditionally with Zend's message (no context flag needed), the backstop in buildTypeCheckFromNode() reports identical text, and scope-precedence is preserved because validateClassScopeTypeKeywords() runs before the compound validator in every declaration context.

Tests: negatives for bare and DNF intersections across parameters, returns, properties, constants and promoted parameters (self, parent with a real parent, static in returns); positive coverage that (Ia&Ib)|self|parent|static union members still compile. Every fixture was first executed under real PHP 8.4.13. If 8.5 relaxes bare intersections here I'm happy to gate it, but 8.4 is unambiguous.